The Windows 10 Developer Preview provides an early look at the tools and features coming with the Windows universal app platform (UAP).

To get started, we need to first sign up for Windows Insider Program

OS and development tools, SDK preview edition can be downloaded after signing up for Windows Insider Program 

1.     Download and install Win10 preview ISO on your development and test machine

Public download latest version till date – 10049.

Please note that this version of OS will expire and it’s not complete version. You may need to keep the preview version updated until its release

2.     Download and install Visual Studio 2015 CTP 6

3.     Download and install Visual Studio 2015 Tools for Windows 10 Preview

Understanding universal apps for Windows 8.1 and Windows 10 Preview UAP

Universal Apps targeting Windows 8.1 devices:

When we target Windows 8.1 devices, we have one solution with three separate projects and two builds, one build each for Windows Phone and Windows Client. Universal Apps in Windows 8.1 platforms means that we can share our code across these two projects (apps targeting Windows Phone and apps targeting Windows Client).

To differentiate platform-specific code in shared (third) project, we use #ifdef directive. We use predefined constants WINDOWS_APP and WINDOWS_PHONE_APP in C#

#if WINDOWS_APP

               //Windows platform related code

#endif

#if WINDOWS_PHONE_APP

                //Windows Phone platform related code

#endif

In C++, for Phone-specific code, we use WINAPI_FAMILY_PHONE_APP directive. For example:

#if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP

        //Windows Phone platform related code

#else

         //Windows platform related code

#endif

Universal Apps targeting Windows 10 devices:

When we target Windows 10 devices, we have one solution with one project (by default) with one build (app) that runs across all Windows 10 devices. Universal Apps Platform (UAP) in Windows 10 means that virtually everything is shared on all devices.

We need to design pages using adaptive UI controls and new layout panels so that they render properly, on all devices, used to view them.

UAP provides a guaranteed API layer and adaptive UI controls based on Windows Core. Windows Core is the new refactored common core of Windows with common set of APIs and infrastructure. Windows Core helps in true binary compatibility across different platforms. With the guaranteed API layer, various devices add their own unique APIs so that we (developers) can create custom, tailored app using unique features of these devices.

UAP is a collection of contracts and versions. It defines the platform that is running your app and acts as a broker between the app and the operating systems. With UAP, we (developers) will need to shift from targeting OS to UAP.

To targeting platforms with the UAP, we just need to update TargetPlatform in the manifest.

For example:

<TargetPlaform Name="Microsoft.Universal" minVersion="3.0.0.0" maxVersionTested="4.5.0.0" />

Figure depicts Windows Core and universal device family inheriting properties from respective device families.

Extensions SDK allows device specific APIs to be accessible in UAP based app. For example, UAP will not be able to provide access to types like BackButtonPressed in targeting Windows Phone platform, if we do not add Windows Phone extension SDK as a reference in our app project.

Unlike Universal Apps in Windows 8.1 platform mentioned above, in UAP Win 10 app, the easiest way to look for certain API or device is by using Foundation Metadata namespace. ApiInformation static class helps in identifying current platform(s), supported classes, contracts, APIs, etc.

// Cache the value if it is going to be used more than once.

bool isHardwareButtonsAPIPresent = Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons");

    if (isHardwareButtonsAPIPresent)

    {

        Windows.Phone.UI.Input.HardwareButtons.CameraPressed +=

            HardwareButtons_CameraPressed;

    }

There is no need for conditional compilation, as the HardwareButtons class and the Backpressed event is included in the UAP, even though the runtime type does not exist in the current device.

We can also test the presence of individual members by using IsEventPresent, IsMethodPresent, IsPropertyPresent, etc, instead of IsTypePresent. The set of APIs within a device family is further divided into subdivisions called API contracts. We can use ApiInformation.IsApiContractPresent method to check if an API contract is present.

And here’s a very cool MVA course to dig deeper with Windows 10 developer preview:

http://www.microsoftvirtualacademy.com/training-courses/a-developers-guide-to-windows-10-preview

PS: The information provided in this post relates to Windows 10 preview build and details may change with Windows 10 release.

Disclaimer: This post is provided "AS IS" with no warranties and confer no rights.

Tech Evangelist at Microsoft gets opportunities to work on multiple domains. I have been focusing on game dev and cloud for past couple of years. However, this new IoT opportunity intrigued me and led me to an interesting case. Here’s a tale of few bytes.

A couple of months back when Windows Phone 8.1 was released, new functionalities including BTLEsupport were added. I got in touch with an innovative device manufacturer.  They had built a nice small device which could control switch to turn lights on and off, changing TV channels etc. This device was based on BTLE and used custom GATTprofiles. Interestingly, this device was able to pair with Android and iPhone however, failed to show up on Windows Phone 8.1. Well, we knew the issue at that time. Even though with WP8.1 BTLE support was announced, the drivers were not bundled in developer preview.

Once Lumia 630 was launched, (comes with WP8.1 RTM edition) we tried to pair it with this IoT device and failed again. This was a major concern because we were again failing to see the device on WP8.1 with Bluetooth.

Initially, we thought that the custom GATT profile implementation by the device manufacturer might have bugs. Though this should have not stopped the device to at least show up in the list of available Bluetooth devices on Lumia 630. With further digging we figured out that this problem was not related to any particular GATT profile, since advertising and BTLE pairing occurs prior to any profile connections.

Here’s an example of WP BTLE HCI activity when finding a device and pairing to it:

            85            Command 0x200c     2                          HCI_LE_Set_Scan_Enable        

                87            Event       0x200c     4                             HCI_LE_Set_Scan_Enable         Command Complete                Success                   

                114          Event                       23                            LE Advertising Report

Bluetooth Device Address: 0x90-59-af-06-f6-b1                      

                120          Command 0x200d    25                      HCI_LE_Create_Connection                                                    

                                                                                                                       Bluetooth Device Address: 0x90-59-af-06-f6-b1                      

                122          Event       0x200d    4                              HCI_LE_Create_Connection     Command Status      Success   

                123          Event                       19            0x000a     LE Connection Complete         Success   

                126          M             Pairing Request        15                           

                128          2              Pairing Response      15                           

                129          M             Pairing Confirm        25                           

                131          2              Pairing Confirm        25                           

                132          M             Pairing Random        25                           

                134          2              Pairing Random        25                           

                138          2              Encryption Information            25                           

                139          2              Master Identification               19                           

                140          2              Identity Information 25                           

                141          2              Identity Address Information   16                           

                142          M             Signing Information  25                          

With this, we closed on our investigation and next step was to find out how this scan, advertisement and pairing happens with the IoT device. We asked the device manufacturer to send their advertisement and scan packet details.

Here’s how TI’s Sensor tag works. This device was pairing with WP8.1 RTM

Advertisement Packet

Scan Response packet

Here’s how device manufacturer was sending packets with their IoT device

Advertisement Packet

Scan Response packet

Their IoT device advertisement structure had additional packets. When we removed them, WP8.1 was able to detect and pair with their device. However, we were not sure why WP8.1 failed to detect the device with additional packets, so we went deeper to understand the root cause.

In their additional packets, vendor section size was set to 0x2 which was not valid.  Their IoT device was not spec compliant and Windows Phone 8.1 was rejecting the payload. Vendor specific section must contain at least 3 bytes (1 byte for the section type (0xff) and 2 bytes for the manufacturer code)

Reference:  Core Specification Supplement (https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=282152)

Part A:

1.4.1 Description

The Manufacturer Specific data type is used for manufacturer specific data. The first two data octets should contain a company identifier code from the Assigned Numbers - Company Identifiers document. The interpretation of any other octets within the data shall be defined by the manufacturer specified by the company identifier.

Additionally, we found that BT Core_V4.0 spec Volume 3 Part C Section 11 “Advertising and Scan Response Data Format” Figure 11.1 shows that each AD structure consists of:

      1 octet: <Length>

      1 octet: <AD Type>

      <Length> - 1 octets: <AD Data>

Applying Appendix C “EIR and AD Formats” Section 18.11 “Manufacturer Specific Data” to the above we see that the format of the AD structure in this case should be:

      1 octet: <Length>  [Must be *at least* 3]

      1 octet: 0xFF [AD Type == Manufacturer Specific]

      2 octets: Company Identifier

      <Length – 3> octets: <Manufacturer specific data>

The IoT device failed to meet the specified format for the AD structure of “Manufacturer Specific Data” in 2 ways:

1.       The <Length> field value of 0x02 is too small to be valid, it must be at least 3

2.       The Company ID should be the first 2 bytes of the “Manufacturer Specific Data” but it was missing

To fix the issue, we asked device manufacturer to update the format of the Advertisement structure for the “Manufacturer Specific Data” to:

      1 octet: 0x04 <Length>

      1 octet: 0xFF [AD Type == Manufacturer Specific]

      2 octets:< company ID >

      1 octet: 0x00 or 0x01 depending on whatever “gesture” value they wanted to advertise

So, at the end a few bytes were held responsible and updating the information helped resolve the issue. In case you are building such device or happen to work on such devices, please make sure that your device pass the BT LE qualification tests.

For those who are interested to know more, here’s how Windows Phone work with BTLE:

1.       Establishing a Connection

Windows 8.1 will automatically connect to a device when an application has a registered a handler for the GattCharacteristic.ValueChanged event. However the basic definition of the services included in the Proximity Profile does not contain any indicatable or notifiable characteristics. A device can add a service that contains an indicatable or notifiable characteristic to the services included in the Proximity Profile. This means that a proximity device must support at least one indicatable or notifiable characteristic value and an application must register at least one handler to a GattCharacteristic.ValueChanged event for the connection to be automatically established.

2.       Detecting Loss of Connection

As mentioned in Bluetooth Proximity Profile, Windows 8.1 does not expose the RSSI value of Bluetooth connections. Consequently, apps cannot use the RSSI value to calculate the connection path loss. Instead, we recommend that a device tie its proximity to the link loss event.

3.       Bluetooth GATT—Windows.Device.Bluetooth.Gatt

·         The API lets Windows Store app developers implement GATT client profiles for collecting data from low energy (LE) sensors.

·         A Bluetooth 4.0 radio is required to use the GATT API.

·         The GATT API prevents access to the following in-box and invalid services:

Service ID    Service (Bluetooth SIG name)

0x1812          HID Over GATT Service

·         The GATT API provides read-only access to the following in-box and invalid services:

Service ID    Service (Bluetooth SIG name)

0x1800          GAP Service

0x1801          GATT Service

0x1813          Scan Parameters Service

Note:  The Windows Runtime APIs for RFCOMM and GATT are not intended for use in Control Panel apps.

Additional References:

1.       Bluetooth LE Proximity Profile Devices and Apps http://msdn.microsoft.com/en-us/library/dn423914(v=vs.85).aspx

2.       Bluetooth hardware implementation on Windows Phone: https://dev.windowsphone.com/en-us/OEM/docs/Driver_Components/Bluetooth

Thanks to Jeff and Alain from product group and Kuldeep for their valuable inputs.

Last week @msdevindia team hosted 2 hours of “Game Development” chat on Twitter with #AskMSDevs tag. I really enjoyed answering  “game development” related questions from developers across the country.

We had a decent participation and I believe people have already started with their game development for Windows platform. Here’s some interesting facts from the Twitter based AskMSDevs chat:

Thanks everyone for joining the session!

Here’s some top queries and my answers.

1. How to start game development for Windows platform. Any tutorials available?

To start with game development one can go through a very nice MVA training “Gaming Engines for Windows 8 Jump Start” available through the following link: http://www.microsoftvirtualacademy.com/training-courses/gaming-engines-for-windows-8-jump-start

2. Considering performance for #gamedev  What do you suggest C++/DirectX or a cross platform game engine?

Well if you really need high performance GPU based support for the game, you can choose C++/DirectX over cross platform game engines.

To begin with C++/DirectX game development, there’s another nice MVA course “Introduction to C++ and DirectX Game Development Jump Start”  http://www.microsoftvirtualacademy.com/training-courses/introduction-to-c-and-directx-game-development-jump-start

3. For developing 2D games, there are #html5 game engines. Which one do you think is the best to start? And

Can I easily develop and publish the Unity 2D (made on v4.3 and above) to windows phone 8?

Construct2 from Scirra is a great engine to start with 2D HTML based game development. The first MVA link in this blog covers that. You can also look at GameSalad and GameMaker for HTML based game developments

Unity also introduced 2D based game development platform. A very nice video tutorial series is available here: http://indiedevspot.azurewebsites.net/2014/04/25/build-a-2d-top-down-game-zero-to-published-part-1/

4. Can we now develop Universal Windows game apps?

Yes, both Microsoft and Unity support universal game development targeting Windows Phone and Windows store. You can choose C++/DirectX or Unity to create universal games

5. What are the important things/aspects should I take into consideration/target before starting #gamedev?

In today’s gaming world, practically every type of game already exists. Therefore, to be successful you would need to think of unique ideas for games, or present an existing idea in a unique way.

Know your audience: It’s important that you understand the target audience. Analyze who and why people will play your game when there are tons of similar games out there. One way to stand out amongst the crowd is to have a “best at” statement. For example, this game is “best at” letting kids learn alphabets.

Truly knowing your audience will help you in building

• User Experience strategy
• Marketing strategy
• Monetization strategy

There are multiple dimensions of analysis before you start your game development.

• Pricing
• Peculiarity
• Platforms

One needs to apply “Design Thinking” before proceeding with any development. However, planning plays a critical role especially in case of game development where user experience is most important

6. While targeting a mob platform, what should I consider for best performance - Device memory or processor speed?

On Windows Phone device memory has higher priority over processor speed. In fact one can neglect the processor speed and focus solely on memory. Windows Phone comes in two segments based on memory 512 MB, low memory devices and 1GB, 2GB high end memory devices.

If you do not want to compromise great graphics and still want to reach low memory device consumers, you can have two separate builds. Follow this link to know further: http://blogs.msdn.com/b/ujjwalk/archive/2014/04/16/game-apps-submission-for-windows-phone-8-low-end-devices.aspx

7. Is MS planning any new SKDs for Unity3D?

·         Prime31 has released great plugins for Unity3D some are absolutely free and others are paid: https://prime31.com/plugins# Check out Windows Store and Windows Phone tabs

·         BitRave has free Unity and Azure plugins http://www.bitrave.com/unity-windows-8-plugins/ and

http://www.bitrave.com/azure-mobile-services-for-unity-3d/

8. How often should we provide updates?

This depends on the game, genre, target audience and most important “User Feedbacks”. It’s highly recommended to review and implement meaningful user feedbacks as soon as possible.

Traditionally, quality mobile game developers, who manage to retain most of their users put an update at least every 2 -3 months.

9. Once I have developed my game, how can I monetize my game?

Monetization strategy should be included in the beginning, at the planning stage itself. You can go for premium or freemium models. In my experience, I have seen premium games doing quite well provided there is some trial experience for end users.

You can also choose to go free with Ads and provide Ads free version at charge. However, what works best is IAP (In App Purchase) model for most of the mobile games.

Additional references:

i.                     Monetization and business models http://msdn.microsoft.com/en-us/library/windows/apps/hh465433.aspx

ii.                   http://www.tobiahmarks.com/2014/03/marketing-monetization-strategies/

In case you have further queries, please feel free to reach out to me. Please do join my talk at Techgig tomorrow, 26th June 2014, 3:00 – 4:00pm IST, to know more about cloud based game development with focus on compute.

http://www.techgig.com/expert-speak/Cloud-enable-your-Game-Computation-and-Match-making-589

Microsoft India is conducting the first Unity Porting Labs in Bangalore in partnership with Intel and Dumadu Games. Come join for a full day fun to develop and port your Unity based games on Windows and Windows Phone platforms.

Calling C# code from C++ for Windows Phone apps and games

Often Windows Phone C++ developers get stuck when they need to call implemented C# functionalities in their C++ project. Especially, game developers working on Cocos2d-x and C++ need to call Facebook SDKs and In App Purchase (IAP) APIs which currently have only C# implementation for Windows Phone platform.

In this post, I am sharing steps to call C# code from C++ while building Windows Phone apps and games. C++/CX is not Managed C++, it’s a C++ component extension.

1.       Create XAML and Direct3D apps for Windows Phone 8 for Cocos2d-x. Details: http://msdn.microsoft.com/en-us/library/windowsphone/develop/jj207012(v=vs.105).aspx

2.       Create a Windows Runtime component library.

3.       Define a public interface class in a C++/CX header for the C# to implement (C++ to call) (e.g. ICallback).

4.       Define a public ref class in a C++/CX header for the C++ to implement (C# to call) (e.g. CppCxClass).

5.       Add a method in CppCxClass that passes and stores an ICallback. (A C++ global variable is shown for conciseness, you can use a better place to store this in your code-base).

ICallback^ globalCallback;

...

void CppCxClass::SetCallback(ICallback ^callback)

{

    globalCallback = callback;

}

6.       Reference the WinRT library in your C# code.

7.       C# code: create an instance of CppCxClass using var cppObject = new CppCxClass().

8.       C# code: create a class which implements ICallback (e.g. CSharpCallbackObject).

9.       C# code: pass an instance of CSharpCallbackObject down to C++. E.g. cppObject.SetCallback(new CSharpCallbackObject()).

You should now be able to call C# with globalCallback->CallCsharp(L"Hello C#");.  And you should be able to extend either ICallback and/or CppCxObject to do the rest of your tasks.

Code snippets:

C++/CX

//.h
[Windows::Foundation::Metadata::WebHostHidden]
public interface classICallback
{
public:
    virtualvoidExec( Platform::String ^Command, Platform::String ^Param);
};
//.cpp
ICallback ^CSCallback = nullptr;
voidDirect3DInterop::SetCallback( ICallback ^Callback)
{
    CSCallback = Callback;
}
//...

if (CSCallback != nullptr)
    CSCallback->Exec( "Command", "Param" );

C# code

publicclassCallbackImpl : ICallback
{
    publicvoidExec(StringCommand, StringParam)
    {
        //Execute some C# code, if you call UI stuff you will need to call this too
        //Deployment.Current.Dispatcher.BeginInvoke(() => {
        // //Lambda code
        //}
    }
}
//...
CallbackImpl CI = newCallbackImpl();
D3DComponent.SetCallback( CI);

Next, I will post on getting started with Cocos2d-x for Windows Phone and Windows Store games. Unity3D content will follow soon after Cocos2d-x

More on C++/CX http://msdn.microsoft.com/en-us/magazine/dn166929.aspx

While we encourage to build game apps targeting all Windows Phone 8 devices. There are scenarios where game developers end up having two builds.

·         First build which has high quality content and targets 1GB or higher RAM based devices

·         Second build which is optimized for 512MB RAM (Low memory Windows Phone 8 devices)

This post is to help folks submitting both these builds to Windows Phone store under same app name:

1.       Use the same product id. Better to use the product id generated from Windows Phone store

a.       To get the product id login to Windows Phone store http://dev.windowsphone.com

b.      Click on Dashboard

c.       Select the app and then click on details tab

d.      Scroll down to get App Id, copy this App Id

e.      Replace your product id in WMAppmanifest.xml file under Packaging Tab

2.       To build app targeting only 1GB RAM based device, you will need to opt out low memory device

This can be achieved by forcing memory cap requirements in WMAppManifest.xml

Add the following tag

Example

<App>

…

  <Requirements>

      <Requirement Name="ID_REQ_MEMORY_300" />

  </Requirements>

</App>

You can refer to How to modify the app manifest file for Windows Phone 8 for further information.

3.       After step 2 implementation, your XAP file (app) will not be visible to consumers with low memory 512MB RAM based devices; once it’s certified and available on store.

4.       You can also extend the 512MB RAM based device peek memory usage cap from 150MB to 180MB by adding Functional Capability:

<FunctionalCapabilities>

    <FunctionalCapability Name="ID_FUNCCAP_EXTEND_MEM"/>

  </FunctionalCapabilities>

Once you have both the builds, add these two XAPs instead of upgrading under the same app name.

Click on “Add New”

You will see two XAP files post this. Fill in other required details and submit for certification.

Certification team will test both the XAPs and app will be available on store directly or for you to publish it manually, as per your submission selection.

The advantage with this approach is that you can target both low end and 1GB RAM based devices with appropriate quality of graphics content. While the disadvantage is that you will have to maintain two builds. In this case your app customers will get the appropriate quality of graphics content based on their devices.

Additional References:

1.       http://msdn.microsoft.com/en-us/library/windowsphone/develop/jj681682(v=vs.105).aspx

2.       http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh855081(v=vs.105).aspx

The much awaited Visual Studio 2012 launch is just around the corner.

I will be delivering session on “Developing Applications for Windows 8 and Windows Azure using Visual Studio 2012” in Bangalore and Hyderabad.

There are other exciting sessions on Building Apps using C++, Application Lifecycle Management (ALM), Building Modern Apps etc.

In case you are interested, please register using the link mentioned below.

Make History - Set a Guinness World Record - Register today for Windows 8 AppFest

To get started with Windows 8 apps development – comprehensive links and resources

 Download this document - Windows 8 store style apps development resources

  For similar Windows Phone apps development resources - please refer to my previous blog post

  Thanks to Raj, Harish, Pali, Sudhir and Rama for their reviews and valuable feedbacks.

  To all the app developers, hope this helps you build quality apps for Windows 8 platform. Your comments and queries are welcome!

1.      Windows Phone 7.1 SDK .iso file download (700+ MB)

2.      Windows Phone SDK 7.1.1 Update

    http://www.microsoft.com/en-us/download/details.aspx?id=29233 (290 MB)

3.      Windows Phone SDK 7.1 Training Course

    http://msdn.microsoft.com/en-us/WindowsPhoneTrainingCourse

4.      Windows Phone Samples: learn through code http://code.msdn.microsoft.com/wpapps/site/search

5.      Windows Phone 7 Development for Absolute Beginners https://channel9.msdn.com/Series/Windows-Phone-7-Development-for-Absolute-Beginners

6.       Design Windows phone

    Design tutorials

    Design Templates for Windows Phone 7

    Windows Phone Design Day Recordings

7.      How-To Index for Windows Phone scenario-based walkthroughs

8.      Windows Phone apps certification requirements guidelines

A collection of useful resources including articles, source code, controls for Windows Phone 7 development

http://indyfromoz.wordpress.com/windows-phone-7-resources

COMPREHENSIVE OVERVIEW

The following table is a comprehensive list of what’s new in the Windows Phone SDK documentation for the 7.1 release.