So, I recently discovered www.DVLUP.com, if you haven't heard of them they reward Windows Phone developers for taking part in various challenges which are aimed at improving the quality of your apps. Completing challenges earns you XP and once you've earned enough XP you can spend it on cool rewards like new devices and marketing campaigns.

However when looking through the challenges I noticed that most of them require your app to have "All 3 Live Tile Sizes", with both of my apps being XNA and targeting the 7.1 OS this presented a problem since the wide tile size isn't natively available. After doing some research I found a couple of different ways to add the wide tile but they required a lot of fiddling like renaming your XAP files to .ZIP and unpacking it to add the image... or another option was to use MangoPollo which is a sort of wrapper for using WP8 functionality in WP7 apps, but again it had problems like forcing the app to restart when adding the tile.

So... in the end i just sort of hacked my own solution using bits of code from both of the previously mentioned solutions, both of my apps have since passed certification and have been accepted for the DVLUP challenges. The only drawback is that the app has to be launched once before the wide tile will be available to the user... anyway heres how I did it:

Both of my Apps are built with XNA4 and im using Visual Studio 2012 with the WP8 SDK targeting 7.1 OS, the wide tile I create is just a static image but you can create a flip tile or whatever without too much fuss.

First thing to do is create the image for your wide tile, the dimensions are 691 × 336 pixels, once you've got your image create a new folder in your game project (I called the folder 'TileImg') then simply add your image to the folder with the following properties:

build action: none
copy to output directory: copy if newer

Now that we have the image for our wide tile we need to alter the WMAppManifest file, add the following code below <Deployment> and above <App> in your Manifest file:

  <AppExtra xmlns="" AppPlatformVersion="8.0">
    <Extra Name="Tiles"/>
</AppExtra>

Then in Game.cs we will need to make several changes, firstly we set our target OS to WP 7.8 because that's the first version to allow wide tiles (7.10.8858 is the official version of WP 7.8). Then we check what version OS the user has, if its greater than the target version then 'IsTargetedVersion' will be true:

       private static Version TargetedVersion = new Version(7, 10, 8858);
        public static bool IsTargetedVersion { get { return Environment.OSVersion.Version >= TargetedVersion; } }

Now we write a new static method, if the user has WP 7.8 or better installed on their phone then a new wide tile is created using the image we added earlier... if the OS is less than 7.8 then it does nothing (you'll also need to add 'using Microsoft.Phone.Shell;' to your using statements:  

        public static void CreateWideTile()
        {
            if (IsTargetedVersion)
            {
                try
                {
                    // Get the new FlipTileData type.
                    Type flipTileDataType = Type.GetType("Microsoft.Phone.Shell.FlipTileData, Microsoft.Phone");
                    // Get the ShellTile type so we can call the new version of "Update" that takes the new Tile templates.

                    Type shellTileType = Type.GetType("Microsoft.Phone.Shell.ShellTile, Microsoft.Phone");
                    // Loop through any existing Tiles that are pinned to Start.

                    foreach (var tileToUpdate in ShellTile.ActiveTiles)
                    {
                        // Get the constructor for the new FlipTileData class and assign it to our variable to hold the
                        Tile properties.
                        var UpdateTileData = flipTileDataType.GetConstructor(new Type[] { }).Invoke(null);
                       
                        // Set the properties. 
                        SetProperty(UpdateTileData, "WideBackgroundImage", new Uri("/TileImg/LargeTile.png",
                        UriKind.Relative));                        

                        // Invoke the new version of ShellTile.Update.
                        shellTileType.GetMethod("Update").Invoke(tileToUpdate, new Object[] { UpdateTileData });
                        break;
                    }
                }
                catch
                {
                }
            }
        }

        private static void SetProperty(object instance, string name, object value)
        {
            var setMethod = instance.GetType().GetProperty(name).GetSetMethod();
            setMethod.Invoke(instance, new object[] { value });
        }

and finally we have to call the method we just created, we do this as soon as the app is launched:

        protected override void OnActivated(object sender, System.EventArgs args)
        {
            if (SaveComponent.wideTileCreated == false)
            {
                SaveComponent.wideTileCreated = true;
                CreateWideTile();
                SaveComponent.SaveWideTile();
            }
            base.OnActivated(sender, args);
        }

You'll notice that I have a flag called SaveComponent.wideTileCreated... once the app has checked the OS version and decided whether the wide tile should be created or not this flag is set to true and saved so that we never check again.

Well that's it... your users now have a nice new Wide Tile they can pin to their start screen and you can enter the DVLUP challenges :D