What’s new in Azure Data Catalog


The Azure Data Catalog (aka previously PowerBI Data Catalog) has released in public preview on last monday(July 13th) @WPC15, which typically reveals a new world of storing & connecting #Data across on-prem & azure SQL database. Lets hop into a quick jumpstart on it.

Connect through Azure Data Catalog through this url  https://www.azuredatacatalog.com/ by making sure you are logging with your official id & a valid Azure subscription. Currently , it’s free for first 50 users & upto 5000 registered data assets & in standard edition, upto 100 users & available upto 1M registered data assets.

Provision

 

Lets start with the signing of the official id into the portal.

Signin

Once it’s provisioned, you will be redirected to this page to launch a windows app of Azure Data Catalog.

AzureDC

 

It would start downloading the app from clickonce deployed server.

ADCapp

 

After it downloaded & would prompt to select server , at this point it has capacity to select data from SQL Server Analysis service, Reporting Service, on-prem/Azure SQL database & Oracle db.

Servers

For this demo, we used on-prem SQL server database to connect to Azure Data Catalog.

Catalog

We selected here ‘AdventureWorksLT’ database & pushed total 8 tables like ‘Customer’, ‘Product’, ‘ProductCategory’, ‘ProductDescription’,’ProductModel’, ‘SalesOrderDetail’ etc. Also, you can tags to identify the datasets on data catalog portal.

metadata-tag

Next, click on ‘REGISTER’ to register the dataset & optionally, you can include a preview of the data definition as well.

Object-registration

 

Once the object registration is done, it would allow to view on portal. Click on ‘View Portal’ to check the data catalogs.

Portal

Once you click , you would be redirected to data catalog homepage where you can search for your data by object metaname.

Search

 

SearchData

in the data catalog object portal, all of the registered metadata & objects would be visible with property tags.

Properties

You can also open the registered object datasets in excel to start importing into PowerBI.

opendata

Click on ‘Excel’ or ‘Excel(Top 1000)’ to start importing the data into Excel. The resultant data definition would in .odc format.

SaveCustomer

 

Once you open it in Excel, it would be prompted to enable custom extension. Click on ‘Enable’.

Security

From Excel, the dataset is imported to latest Microsoft PowerBI Designer Preview app to build up a custom dashboard.

ADC-PowerBI

Login into https://app.powerbi.com & click to ‘File’ to get data from .pbix file.

PowerBI

Import the .pbix file on ‘AdventureWorks’ customer details & product analytics to powerbi reports & built up a dashboard.Uploading

The PowerBI preview portal dashboard has some updates on tile details filter like extension of custom links.

PowerBI-filter

 

The PowerBI app for Android is available now, which is useful for quick glance of real-time analytics dashboards specially connected with Stream analytics & updating  real time.

WP_20150715_14_07_48_Pro

WP_20150715_14_13_33_Pro

AdventureWorks-ADC

 

 

 

Advertisements

Pushing realtime Sensors data into ASA & visualize into Near Real-Time (NRT) PowerBI dashboard– frontier of IoT


As per as the last demo on IoT foundation stuffs, we’ve seen how it’s possible to leverage the real-time data insights from social media datasets like Twitter with some keywords. In this demo, we are trying to pushing realtime sensors data from Windows Phone device to Azure Stream Analytics (through Service Bus EventHub channels) & after processing in ASA hub publishing out to realtime PowerBI dashboard or near real-time analytics(NRT) on PowerView for Excel by pushing out ASA events to Azure SQL database through Excel PowerQuery.

An overview of n-tier architecture of  ASA on IoT foundation is like this:

ASA-blog

 

While, IoT always enables customers to connect their own device on Azure cloud platform & bring out some real business value from it, whether it produces #BigData or #SmallData.

Another topic is pretty important is to get insights from Weblogs or telemetry data which can bring out good sentiment, click stream analytics values with machine learning.

Here goes a good high level discussion from IoT team.

Coming back to the demo, so, first implemented a sample app for generating Accelerometer 3D events (X, Y, Z) on Windows Phone & Windows Store devices(Universal app) & pushing the generated events as block blob to Azure Service Bus Event Hub.

Attached sample code snippet.

private async void ReadingChanged(object sender, AccelerometerReadingChangedEventArgs e)
{

await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AccelerometerReading reading = e.Reading;
ScenarioOutput_X.Text = String.Format(“{0,5:0.00}”, reading.AccelerationX);
ScenarioOutput_Y.Text = String.Format(“{0,5:0.00}”, reading.AccelerationY);
ScenarioOutput_Z.Text = String.Format(“{0,5:0.00}”, reading.AccelerationZ);
i++;

//Coordinate_X = String.Format(“{0,5:00.00}”,Coordinate_X + ScenarioOutput_X.Text);
//Coordinate_Y = String.Format(“{0,5:00.00}”, Coordinate_Y + ScenarioOutput_Y.Text);
//Coordinate_Z = String.Format(“{0,5:00.00}”, Coordinate_Z + ScenarioOutput_Z.Text);
dataDetails = i +”,”+ reading.AccelerationX + “,” + reading.AccelerationY + “,” + reading.AccelerationZ;

NewDataFile += Environment.NewLine + dataDetails;

});
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(“DefaultEndpointsProtocol=https;AccountName=yourazurestorageaccountname;

AccountKey=yourazurestorageaccountkey”);

CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

CloudBlobContainer container = blobClient.GetContainerReference(“accelerometer”);
await container.CreateIfNotExistsAsync();
//if (x == false)
//{
// await container.CreateAsync();
//}

CloudBlockBlob blockBlob = container.GetBlockBlobReference(newFileName);
// bool y = await blockBlob.ExistsAsync();
//if (!blockBlob.Equals(newFileName))
//{
container.GetBlockBlobReference(newFileName);
// await blockBlob.UploadTextAsync(dataDetails);

await blockBlob.UploadTextAsync(Headers + Environment.NewLine+ NewDataFile);
}

 

You can download the whole visual studio solution on Github.

BUILD-Kevin-thumbnail-IoT

Next challenge as usual is to send real sensor events to event hubs with accurate consumer key & publish millions of events to event hub at a time.

Here goes sample code snippet.

class Program
{
static string eventHubName = “youreventhubname”;
static string connectionString = GetServiceBusConnectionString();
static string data = string.Empty;
static void Main(string[] args)
{

string csv_file_path = string.Empty;
install();
//string csv_file_path = @””;
string[] filePath = Directory.GetFiles(@”Your CSV Sensor Data file directory”, “*.csv”);
int size = filePath.Length;
for (int i = 0; i < size; i++)
{
Console.WriteLine(filePath[i]);
csv_file_path = filePath[i];
}

DataTable csvData = GetDataTableFromCSVFile(csv_file_path);
Console.WriteLine(“Rows count:” + csvData.Rows.Count);
DataTable table = csvData;
foreach (DataRow row in table.Rows)
{
// Console.WriteLine(“—Row—“);
foreach (var item in row.ItemArray)
{

data = item.ToString();
Console.Write(data);

var eventHubClient = EventHubClient.CreateFromConnectionString(connectionString, eventHubName);
//while (true)
//{

try
{
foreach (DataRow rows in table.Rows)
{
var info = new Accelerometer
{

ID = rows.ItemArray[0].ToString(),
Coordinate_X = rows.ItemArray[1].ToString(),
Coordinate_Y = rows.ItemArray[2].ToString(),
Coordinate_Z = rows.ItemArray[3].ToString()

};
var serializedString = JsonConvert.SerializeObject(info);
var message = data;
Console.WriteLine(“{0}> Sending events: {1}”, DateTime.Now.ToString(), serializedString.ToString());
eventHubClient.SendAsync(new EventData(Encoding.UTF8.GetBytes(serializedString.ToString())));

}
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(“{0} > Exception: {1}”, DateTime.Now.ToString(), ex.Message);
Console.ResetColor();
}
Task.Delay(200);
//}
}

}
// Console.ReadLine();

Console.WriteLine(“Press Ctrl-C to stop the sender process”);
Console.WriteLine(“Press Enter to start now”);
Console.ReadLine();

// SendingRandomMessages().Wait();

}

public static void install()
{
string url = @”https://…………blob.core.windows.net/accelerometer/AccelerometerSensorData.csv&#8221;;
WebClient wc = new WebClient();
wc.DownloadFileCompleted += new AsyncCompletedEventHandler(Completed);
wc.DownloadProgressChanged += new DownloadProgressChangedEventHandler(ProgressChanged);
// Console.WriteLine(“Download OnProgress……”);

ConsoleHelper.ProgressTitle = “Downloading”;
ConsoleHelper.ProgressTotal = 10;
for (int i = 0; i <= 10; i++)
{
ConsoleHelper.ProgressValue = i;
Thread.Sleep(500);
if (i >= 5)
{
ConsoleHelper.ProgressHasWarning = true;
}
if (i >= 8)
{
ConsoleHelper.ProgressHasError = true;
}
}
ConsoleHelper.ProgressTotal = 0;
try
{
wc.DownloadFile(new Uri(url), @”\ASA\Sensors\Accelerometer\AccelerometerSensorData.csv”);
}
catch (Exception ex)
{
while (ex != null)
{
Console.WriteLine(ex.Message);
ex = ex.InnerException;
}
}
}
public static void Completed(object sender, AsyncCompletedEventArgs e)
{
Console.WriteLine(“Download Completed!”);
}

public static void ProgressChanged(object sender, DownloadProgressChangedEventArgs e)
{
Console.WriteLine(“{0} Downloaded {1} of {2} bytes,{3} % Complete….”,
(string)e.UserState,
e.BytesReceived,
e.TotalBytesToReceive,
e.ProgressPercentage);
DrawProgressBar(0, 100, Console.WindowWidth, ‘1’);
}

private static void DrawProgressBar(int complete, int maxVal, int barSize, char ProgressCharacter)
{
Console.CursorVisible = false;
int left = Console.CursorLeft;
decimal perc = (decimal)complete / (decimal)maxVal;
int chars = (int)Math.Floor(perc / ((decimal)1 / (decimal)barSize));
string p1 = String.Empty, p2 = String.Empty;

for (int i = 0; i < chars; i++) p1 += ProgressCharacter;
for (int i = 0; i < barSize – chars; i++) p2 += ProgressCharacter;

Console.ForegroundColor = ConsoleColor.Green;
Console.Write(p1);
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.Write(p2);

Console.ResetColor();
Console.Write(“{0}%”, (perc * 100).ToString(“N2”));
Console.CursorLeft = left;
}
private static DataTable GetDataTableFromCSVFile(string csv_file_path)
{
DataTable csvData = new DataTable();
string data = string.Empty;
try
{
using (TextFieldParser csvReader = new TextFieldParser(csv_file_path))
{
csvReader.SetDelimiters(new string[] { “,” });
csvReader.HasFieldsEnclosedInQuotes = true;

//read column names
string[] colFields = csvReader.ReadFields();
foreach (string column in colFields)
{
DataColumn datecolumn = new DataColumn(column);
datecolumn.AllowDBNull = true;
csvData.Columns.Add(datecolumn);
}
while (!csvReader.EndOfData)
{
string[] fieldData = csvReader.ReadFields();

for (int i = 0; i < fieldData.Length; i++)
{
if (fieldData[i] == “”)
{
fieldData[i] = null;
}
}
csvData.Rows.Add(fieldData);

}
}
}
catch (Exception ex)
{

}
return csvData;
}

 

Now, built out ASA SQL query with specific window interval like in this demo, used ‘SlidingWindow(Second,no of interval)’ which generates computation on event hubs data based on the specific time interval mentioned in window.

ASAQuery

 

Next, start implement the processed output visualization on PowerBI preview portal by selecting ‘Output’ tab of ASA job. Once, you provide all the dataset name of output & start the ASA job, on PowerBI portal, would be able to see the specific dataset is created with a small yellow star icon beside.SensorsPowerBI

 

Here goes a step by step demonstration with video available on my Youtube channel.

A brief tour on Windows 10 Preview


Today, Microsoft officially announced the preview of Windows 10 which is going to be available through Windows Insider program. Everyone is excited to download & install the new preview feature which is upcoming after Windows 8.1 , Windows Phone 8.1 & Windows Server 2012 R2. Well , a lot of new enhancements & magnificent charms like come back of ‘Start‘ menu button on desktop, snap enhancements, new task view button & lots more.

Shared an exciting presentation regarding the upcoming preview edition of Windows 10 & a few more features of it.

 

 

Lets wait for first download time for the next omni-WINDOWS.

What’s new in Windows Phone 8.1 Update GDR 1 & specialised code structures of Universal Apps for Windows Store 8.1 & Windows Phone 8.1 app


Recently, there is a new update of Windows Phone 8.1 GDR 1 is available which embeds few new features on existing Windows Phone 8.1 emulator. You can the download it from here. After downloading the pack, let’s check what’s new in this update.

First , you will be prompted with one folder called ‘packages‘ & ‘MobileTools_EmulatorWP81GDR1‘.

MobEmulatorOn clicking, the ‘packages‘ folder, you will be prompted with GDR1 update packages & .cab files.

Update

Now, go ahead with the installation of ‘MobileTools_EmulatorWP81GDR1′ & make sure before proceeding that you should have visual studio 2013 update 2 (at least) to be installed.

Installation

Upon installation, check the available emulators list in visual studio , there are additional emulators are available as ‘Emulator 8.1 U1‘ extension.

Emulators

Let’s checkout a sample Universal app on Windows Store 8.1 & Windows Phone 8.1 app on webview using C#. The project simply consists of Windows Store 8.1, Phone 8.1 & a shared project which consists of app.xaml & shared configuration details.

 

using System.Collections.Generic;
using Windows.UI.Xaml.Controls;

using System;

namespace SDKTemplate
{
public partial class MainPage : Page
{
// Change the string below to reflect the name of your sample.
// This is used on the main page as the title of the sample.
public const string FEATURE_NAME = “XAML WebView control sample”;

// Change the array below to reflect the name of your scenarios.
// This will be used to populate the list of scenarios on the main page with
// which the user will choose the specific scenario that they are interested in.
// These should be in the form: “Navigating to a web page”.
// The code in MainPage will take care of turning this into: “1) Navigating to a web page”
#if WINDOWS_PHONE_APP
List scenarios = new List
{
new Scenario() { Title = “Navigate to a URL”, ClassType = typeof(Controls_WebView.Scenario1) },
new Scenario() { Title = “Navigate to a String”, ClassType = typeof(Controls_WebView.Scenario2) },
new Scenario() { Title = “Navigate to package and local state”, ClassType = typeof(Controls_WebView.Scenario3) },
new Scenario() { Title = “Navigate with custom stream”, ClassType = typeof(Controls_WebView.Scenario4) },
new Scenario() { Title = “Invoke script”, ClassType = typeof(Controls_WebView.Scenario5) },
new Scenario() { Title = “Using ScriptNotify”, ClassType = typeof(Controls_WebView.Scenario6) },
new Scenario() { Title = “Using CaptureBitmap”, ClassType = typeof(Controls_WebView.Scenario8) }
};
#else
List scenarios = new List
{
new Scenario() { Title = “Navigate to a URL”, ClassType = typeof(Controls_WebView.Scenario1) },
new Scenario() { Title = “Navigate to a String”, ClassType = typeof(Controls_WebView.Scenario2) },
new Scenario() { Title = “Navigate to package and local state”, ClassType = typeof(Controls_WebView.Scenario3) },
new Scenario() { Title = “Navigate with custom stream”, ClassType = typeof(Controls_WebView.Scenario4) },
new Scenario() { Title = “Invoke script”, ClassType = typeof(Controls_WebView.Scenario5) },
new Scenario() { Title = “Using ScriptNotify”, ClassType = typeof(Controls_WebView.Scenario6) },
new Scenario() { Title = “Supporting the Share contract”, ClassType = typeof(Controls_WebView.Scenario7) },
new Scenario() { Title = “Using CaptureBitmap”, ClassType = typeof(Controls_WebView.Scenario8) }
};
#endif
}

public class Scenario
{
public string Title { get; set; }

public Type ClassType { get; set; }

public override string ToString()
{
return Title;
}
}
}

SampleConfiguration.cs

  • The ‘Controls_WebView.Shared’ project also consists of a default ‘SuspensionManager.cs’ file contains Session states data in form of Dictionary<string,object> key/value pair.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using Windows.ApplicationModel;
using Windows.Storage;
using Windows.Storage.Streams;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

namespace SDKTemplate.Common
{
///
/// SuspensionManager captures global session state to simplify process lifetime management
/// for an application. Note that session state will be automatically cleared under a variety
/// of conditions and should only be used to store information that would be convenient to
/// carry across sessions, but that should be discarded when an application crashes or is
/// upgraded.
///

internal sealed class SuspensionManager
{
private static Dictionary<string, object> _sessionState = new Dictionary<string, object>();
private static List _knownTypes = new List();
private const string sessionStateFilename = “_sessionState.xml”;

///
/// Provides access to global session state for the current session. This state is
/// serialized by and restored by
/// , so values must be serializable by
/// and should be as compact as possible. Strings
/// and other self-contained data types are strongly recommended.
///

public static Dictionary<string, object> SessionState
{
get { return _sessionState; }
}

///
/// List of custom types provided to the when
/// reading and writing session state. Initially empty, additional types may be
/// added to customize the serialization process.
///

public static List KnownTypes
{
get { return _knownTypes; }
}

///
/// Save the current . Any instances
/// registered with will also preserve their current
/// navigation stack, which in turn gives their active an opportunity
/// to save its state.
///

/// An asynchronous task that reflects when session state has been saved.
public static async Task SaveAsync()
{
try
{
// Save the navigation state for all registered frames
foreach (var weakFrameReference in _registeredFrames)
{
Frame frame;
if (weakFrameReference.TryGetTarget(out frame))
{
SaveFrameNavigationState(frame);
}
}

// Serialize the session state synchronously to avoid asynchronous access to shared
// state
MemoryStream sessionData = new MemoryStream();
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
serializer.WriteObject(sessionData, _sessionState);

// Get an output stream for the SessionState file and write the state asynchronously
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
using (Stream fileStream = await file.OpenStreamForWriteAsync())
{
sessionData.Seek(0, SeekOrigin.Begin);
await sessionData.CopyToAsync(fileStream);
}
}
catch (Exception e)
{
throw new SuspensionManagerException(e);
}
}

///
/// Restores previously saved . Any instances
/// registered with will also restore their prior navigation
/// state, which in turn gives their active an opportunity restore its
/// state.
///

///An optional key that identifies the type of session.
/// This can be used to distinguish between multiple application launch scenarios. /// An asynchronous task that reflects when session state has been read. The
/// content of should not be relied upon until this task
/// completes.
public static async Task RestoreAsync(String sessionBaseKey = null)
{
_sessionState = new Dictionary<String, Object>();

try
{
// Get the input stream for the SessionState file
StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(sessionStateFilename);
using (IInputStream inStream = await file.OpenSequentialReadAsync())
{
// Deserialize the Session State
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
_sessionState = (Dictionary<string, object>)serializer.ReadObject(inStream.AsStreamForRead());
}

// Restore any registered frames to their saved state
foreach (var weakFrameReference in _registeredFrames)
{
Frame frame;
if (weakFrameReference.TryGetTarget(out frame) && (string)frame.GetValue(FrameSessionBaseKeyProperty) == sessionBaseKey)
{
frame.ClearValue(FrameSessionStateProperty);
RestoreFrameNavigationState(frame);
}
}
}
catch (Exception e)
{
throw new SuspensionManagerException(e);
}
}

private static DependencyProperty FrameSessionStateKeyProperty =
DependencyProperty.RegisterAttached(“_FrameSessionStateKey”, typeof(String), typeof(SuspensionManager), null);
private static DependencyProperty FrameSessionBaseKeyProperty =
DependencyProperty.RegisterAttached(“_FrameSessionBaseKeyParams”, typeof(String), typeof(SuspensionManager), null);
private static DependencyProperty FrameSessionStateProperty =
DependencyProperty.RegisterAttached(“_FrameSessionState”, typeof(Dictionary<String, Object>), typeof(SuspensionManager), null);
private static List<WeakReference> _registeredFrames = new List<WeakReference>();

///
/// Registers a instance to allow its navigation history to be saved to
/// and restored from . Frames should be registered once
/// immediately after creation if they will participate in session state management. Upon
/// registration if state has already been restored for the specified key
/// the navigation history will immediately be restored. Subsequent invocations of
/// will also restore navigation history.
///

///An instance whose navigation history should be managed by
/// ///A unique key into used to
/// store navigation-related information. ///An optional key that identifies the type of session.
/// This can be used to distinguish between multiple application launch scenarios. public static void RegisterFrame(Frame frame, String sessionStateKey, String sessionBaseKey = null)
{
if (frame.GetValue(FrameSessionStateKeyProperty) != null)
{
throw new InvalidOperationException(“Frames can only be registered to one session state key”);
}

if (frame.GetValue(FrameSessionStateProperty) != null)
{
throw new InvalidOperationException(“Frames must be either be registered before accessing frame session state, or not registered at all”);
}

if (!string.IsNullOrEmpty(sessionBaseKey))
{
frame.SetValue(FrameSessionBaseKeyProperty, sessionBaseKey);
sessionStateKey = sessionBaseKey + “_” + sessionStateKey;
}

// Use a dependency property to associate the session key with a frame, and keep a list of frames whose
// navigation state should be managed
frame.SetValue(FrameSessionStateKeyProperty, sessionStateKey);
_registeredFrames.Add(new WeakReference(frame));

// Check to see if navigation state can be restored
RestoreFrameNavigationState(frame);
}

///
/// Disassociates a previously registered by
/// from . Any navigation state previously captured will be
/// removed.
///

///An instance whose navigation history should no longer be
/// managed. public static void UnregisterFrame(Frame frame)
{
// Remove session state and remove the frame from the list of frames whose navigation
// state will be saved (along with any weak references that are no longer reachable)
SessionState.Remove((String)frame.GetValue(FrameSessionStateKeyProperty));
_registeredFrames.RemoveAll((weakFrameReference) =>
{
Frame testFrame;
return !weakFrameReference.TryGetTarget(out testFrame) || testFrame == frame;
});
}

///
/// Provides storage for session state associated with the specified .
/// Frames that have been previously registered with have
/// their session state saved and restored automatically as a part of the global
/// . Frames that are not registered have transient state
/// that can still be useful when restoring pages that have been discarded from the
/// navigation cache.
///

/// Apps may choose to rely on to manage
/// page-specific state instead of working with frame session state directly.
///The instance for which session state is desired. /// A collection of state subject to the same serialization mechanism as
/// .
public static Dictionary<String, Object> SessionStateForFrame(Frame frame)
{
var frameState = (Dictionary<String, Object>)frame.GetValue(FrameSessionStateProperty);

if (frameState == null)
{
var frameSessionKey = (String)frame.GetValue(FrameSessionStateKeyProperty);
if (frameSessionKey != null)
{
// Registered frames reflect the corresponding session state
if (!_sessionState.ContainsKey(frameSessionKey))
{
_sessionState[frameSessionKey] = new Dictionary<String, Object>();
}
frameState = (Dictionary<String, Object>)_sessionState[frameSessionKey];
}
else
{
// Frames that aren’t registered have transient state
frameState = new Dictionary<String, Object>();
}
frame.SetValue(FrameSessionStateProperty, frameState);
}
return frameState;
}

private static void RestoreFrameNavigationState(Frame frame)
{
var frameState = SessionStateForFrame(frame);
if (frameState.ContainsKey(“Navigation”))
{
frame.SetNavigationState((String)frameState[“Navigation”]);
}
}

private static void SaveFrameNavigationState(Frame frame)
{
var frameState = SessionStateForFrame(frame);
frameState[“Navigation”] = frame.GetNavigationState();
}
}
public class SuspensionManagerException : Exception
{
public SuspensionManagerException()
{
}

public SuspensionManagerException(Exception e)
: base(“SuspensionManager failed”, e)
{

}
}
}

WebControl

Universal App : Windows Phone 8.1 webview app

screenshot_08092014_002735Universal App: Windows Store 8.1 WebView app

A Lap Around of Cloud Design Patterns – Microsoft Patterns & Practices


Patterns & Practices are key indicators of any application development life-cycle whether it’s Windows Store / Desktop app, Web , Cloud , mobility or LOB app. Microsoft P & P leverages few new patterns as well for Cloud based apps. Lets have a summation as followed:

1. Cache-aside Pattern.

2. Circuit Breaker Pattern.

3. Compensating Transaction Pattern.

4. Compensating Consumers Pattern.

5. Compute Resource Consolidation Pattern.

6. Command and Query Responsibility Segregation(CQRS) Pattern.

7. Event Sourcing Pattern.

8. External Configuration Pattern.

9. Federated Identity Pattern.

10. Gatekeeper Pattern.

11. Health Endpoint Monitoring Pattern.

12. Index Table Pattern.

13. Leader Election Pattern.

14. Materialized View Pattern.

15. Pipes and Filters Pattern.

16. Priority Queue Pattern.

17. Queue based Load leveling Pattern.

18. Retry Pattern.

19. Run time Reconfiguration Pattern.

20. Scheduler Agent Supervisor Pattern.

21. Sharding Pattern.

22. Static Content Hosting Pattern.

23. Throttling Pattern.

24. Valet Key Pattern.

25. Asynchronous messaging Pattern.

26. Autoscaling Guidance.

27. Caching Guidance

28.Compute Partitioning Guidance.

29. Data Consistency Primer.

30. Data Partitioning Guidance.

31. Data Replication & Synchronization Guidance.

32. Instrumentation & Telemetry Guidance.

33. Multiple Data Center Deployment Guidance.

34. Service Metering Guidance.

 

Take a look of this link to deep dive into each of pattern’s architecture , key scenario considerations.

To have a complete overview on the projects executed by P&P team, have a look at this site.

 

 

Developing apps for Windows Phone 8 & Windows 8.1 using Windows Phone App Studio


The latest Windows Phone App Studio allows windows app developers not only to develop windows phone 8.0 or 7.1.1 apps but also to develop apps that can be ported to windows 8.1 app store itself. Lets take a look what’s new in newly updated windows phone app studio web based portal which relives developer’s development life cycle to few mins to deploy on marketplace.

windows phone app studio

windows phone app studio

  • Since, in this demo, I am developing an app for a small business , henceforth, from template selecting the app named ‘Contoso Ltd‘.
  • After clicking on it, it allows to move to app introduction page.

Contoso App create

  • Next, after creation of the app, move on to the app development dashboard, since the app is implemented initially with demo data, adding a few live data in it.

Data Collection

  • Similar way, you can import data from comma seperated csv files, export existing data into csv itself. The data collection format is available in default static collection & WCF service,OData, RSS, Atom based dynamic data feed.
  • After move on to the next option of Tile & Splash & lock screens. For Windows Phone 8.0, here is the option comes for both Cyclic, Iconic & Flip types. You only need to select the corresponding images along with content.

Tile

  • Select, the splash screen & lock screen icon similarly, while selecting images you would be prompted to few options.

ImageSplash & Lock

  • For each & every development module , you would need to save the changes by clicking the Save icon.

Save

  • Finally, proceed to generation info, check the publication package (.xap) file, certificate needs to install in your windows phone device & Click on Generate.

Publish

Generate Package

  • After clicking Generate button, you would find the following options, the default one is windows phone 8.0 app package along with source code, while the second one is the .appx file that can be shared across windows 8.1 & windows phone 8.0 along with Visual studio 2013 solution.

App gen option

  • Once , you click Generate the following screen would come up.

generate

  • Check option of downloading source code of the app along with app package. Download the bar code in order to install the app on your device.

Publish & code

  • Lets look out the app after porting into device.

App

Catalog page

Team Page

  • Check out the tile screen, while I have added few icons for small , iconic tiles itself.

small

  • If you check the app About section, you should be able to find see the text that, the app is made of Windows Phone App Studio along with app assembly version info.

About

 

  • Windows 8.1 view of the app while debugged from same shared code in VS 2013.

screenshot_02262014_171120

Building Cross-Platform Mobile apps with Icenium for iOS,Android on Visual Studio 2012


Recently announced, the visual studio ultimate 2012 extension of Icenium (Kendo UI for Mobile) by telerik , a cross- platform mobile app framework based on PhoneGap, jQuery Mobile for iOS & Android. The Visual Studio 2012 ultimate extension can be downloaded from here.

Lets start , what’s new in this version of Icenium template. So, open Visual Studio 2012 ultimate & select Icenium template from Project templates.

Kendo

The latest release contains the following updates :

  • Icenium extension for Visual Studio (Beta): .NET developers can fully leverage Icenium mobile development platform directly from Visual Studio! This allows for quick development of cross-platform apps for both iOS and Android. In addition Team Foundation Server (TFS) and Subversion (SVN), for example, can now be used in addition to Icenium’s default support for GitHub, making it even easier to integrate Icenium into existing development workflows.
  • Apache Cordova 3.0 update: In Apache Cordova 3.0, every core API is taken apart into a plugin on its own-and Icenium can now take advantage of this new architecture. Users will be able to selectively turn on or off any core plugin. The same option will be available for all out-of-the-box advanced custom plugins such as the Barcode Scanner, PushPlugin, and SQLite.
  • Icenium Mist enhancements: Icenium Mist continues to mature with the inclusion of code analysis, code completion, and its new integrated version control plugin, CodeMirror.

 

  • Run the project by selecting the tab ‘ICENIUM‘ from Visual Studio 2012 & select the option ‘Run Project(Specified in Project Name) in simulator‘.

Run

 

  • The device simulator launches with iPhone,iPhone 5S, iPad, Android Phone & Android Tablet simulators.

PieChart

  • The simulator even specifies the geolocation & network connection feasibility options(viz. wifi, cell2G, cell3G,cell4G, limited) connectivity options.

geolocation

  • The Icenium DataViz project template contains default JSON data for populating charts, gauges along with ‘Cordova‘ framework support for iOS & Android.
  • The source code for these controls looks fairly simple by using jQuery Mobile & Cordova scripts using native html5 & minimized css3

<!DOCTYPE html>
<html>
<head>
<title>Kendo UI DataViz</title>
<meta charset=”UTF-8″ />

<link href=”kendo/styles/kendo.dataviz.mobile.min.css” rel=”stylesheet” />

<!–Once the final theme is chosen the redundant css reference should removed–>
<link href=”kendo/styles/kendo.dataviz.flat.min.css” rel=”stylesheet” />
<link href=”kendo/styles/kendo.dataviz.silver.min.css” rel=”stylesheet” />

<link href=”styles/main.css” rel=”stylesheet” />

<script src=”cordova.js”></script>
<script src=”kendo/js/jquery.min.js”></script>
<script src=”kendo/js/kendo.dataviz.mobile.min.js”></script>

<script src=”scripts/app.js”></script>
<script src=”scripts/pie-chart.js”></script>
<script src=”scripts/gauge.js”></script>
<script src=”scripts/qr-code.js”></script>
<script src=”scripts/stock-chart.js”></script>
</head>

<body>
<!–Pie chart–>
<div id=”tabstrip-pie-chart”
data-role=”view”
data-title=”Pie Chart”
data-show=”app.pieChart.createPieChart”
data-hide=”app.pieChart.unbindResizeEvent”
data-stretch=”true”>

<div data-role=”content” class=”view-content”>
<div id=”pie-chart”></div>
</div>

</div>

<!–Gauge–>
<div id=”tabstrip-gauge”
data-role=”view”
data-title=”Gauge”
data-show=”app.gauge.createGauge”
data-hide=”app.gauge.unbindResizeEvent”
data-stretch=”true”>

<div id=”gauge-wrap” data-role=”content” class=”view-content”>
<div id=”gauge”></div>
<div class=”input-content”>
<input id=”gauge-value” type=”range”>
</div>
</div>

</div>

<!–QR code–>
<div id=”tabstrip-qrcode”
data-role=”view”
data-title=”QR Code”
data-show=”app.qrcode.createQRCode”>

<div data-role=”content” class=”view-content”>
<div id=”qrcode”></div>
<div class=”input-content”>
<input type=”text” id=”qrcode-value” value=”http://www.icenium.com/”&gt;
<a data-role=”button” id=”qrcode-generate”>Update QR</a>
</div>
</div>

</div>

<!–Stock chart–>
<div id=”tabstrip-stock-chart”
data-role=”view”
data-title=”Stock Chart”
data-show=”app.stockChart.createStockChart”
data-hide=”app.stockChart.unbindResizeEvent”
data-stretch=”true”>

<div data-role=”content” class=”view-content”>
<div id=”stock-chart”></div>
</div>

</div>

<!–Layout–>
<div data-role=”layout”
data-id=”mobile-tabstrip”>

<!–Header–>
<div data-role=”header”>
<div data-role=”navbar”>
<a data-align=”right” data-role=”button” data-click=”app.changeSkin”>Flat</a>
<span data-role=”view-title”></span>
</div>
</div>

<!–Footer–>
<div data-role=”footer”>
<div data-role=”tabstrip”>
<a href=”#tabstrip-pie-chart” data-icon=”globe”>Pie Chart</a>
<a href=”#tabstrip-gauge” data-icon=”recents”>Gauge</a>
<a href=”#tabstrip-qrcode” data-icon=”camera”>QR Code</a>
<a href=”#tabstrip-stock-chart” data-icon=”featured”>Stock Chart</a>
</div>
</div>

</div>
</body>
</html>

Android chart

In next article, we will cover the PhoneGap / Cordova  3.0 framework to built native apps on HTML5, CSS3 & jQuery for Windows Store & Windows Phone apps using Windows Azure Mobile Services(WAMS).

 

%d bloggers like this: