Working with .NET in a connected world your new favorite library should be Json.net.  It just makes the world connect in an easy and REST-full way.

The developer of this library is Jason Newton-King, and he’s got a blog that shows you how easy it is to implement.

Not only should it be a natural part of your .NET project but it can also be used for iPhone/iPad development through MonoTouch . Here’s also a guide on how you do it. Hopefully it’ll transfer to MonoDroid when it becomes available.

Download Json.NET from here: http://json.codeplex.com/releases/view/50552

Use Facebook to Comment on this Post

A new C# Facebook SDK makes it easy to connect your apps.

jimzim and ntotten has released their Facebook C# SDK on Codeplex that  helps .Net developers create Facebook iframe and web apps using the most current and fully supported Facebook APIs.

This toolkit allows you to quickly create a facebook application, or integrate your website with Facebook, and use the new Graph API or old rest API.

Visit Codeplext to have a look. Downloadable SDK complete with documentation, getting started docs and sample code is available making it super easy to get your Facebook integration going.

Features

• Compatible with all Graph API and REST API Calls
• Supports all forms of Facebook authentication: Cookies, OAuth 2.0, Signed Requests
• Supports .Net 4.0 and .Net 3.5
• Supports .Net 4.0 Client Profile (WinForms and WPF)
• Supports Silverlight 4
• Supports Windows Phone 7
• Samples Applications to get started quickly
• Client authentication tool to get test access tokens

Im going to check out the Windows Phone 7 support.

Use Facebook to Comment on this Post

But not quite yet. Not in my opinion anyhow, after giving WebOS from Palm a try.  My previous experience with HTML/Javascript/CSS based native apps was by using PhoneGap in an iPhone application, that actually works the way I expected, with the “look and feel” of how i would create any other ordinary web/html application.  With WebOS and the Palm WebOS SDK there’s a different way to do it….

[Update: This post relates to WebOS release 1.4.x]

Firstly, you download and install the SDK and the VirtualBox WebOS emulator. To start a new project you fire up a command prompt or terminal window and type the generate command:

> palm-generate -p “{title:’Hello World’, id:com.mystuff.hello, version:’1.0.0′}” HelloWorld

This generates the basic application folder structure for you with the first “ViewController” called index.html. Then you need to create a View, or a Scene as they call it. (which actually is saved in a folder called views…..) The view is created yet again with the magic palm-generate command at command line.

> palm-generate -t new_scene -p “name:first” HelloWorld

The application run from the emulator should look like this.

You now have a html file called “/app/views/first/first-scene.html”. This is where you place the content of that view/scene.  The content could look like this…

<div id="main">
     <div>Header</div>
     <div id="count">0</div>
     <div id="MyButton"
          name="MyButton1"
          x-mojo-element="Button"></div>
</div>

The ViewController (index.html) is controlled from ‘/app/assistants/stage-assistant.js’ (someone has been fond of the theatre here) and the View/Scene is controlled by ‘/app/assistants/first-assistant.js’

You get your mojo going by hooking the button click event inside ‘first-assistant.js’ and you configure the View/Scene in the setup method.

Ahh.. I phased out… too much code to many places to get a simple button push count app….. If i’d been using Eclipse i could have avoided the trips out to the command line, but I’m not much of a Eclipse fan, and as web/html development it’s too bound to the WebOS platform for me.

Want to try for yourself you can find the complete guide here at Palm Developer Center.

Use Facebook to Comment on this Post

Here’s a code snippet i just found really usefull. I was getting 20 MC75 pda’s ready for a customer pilot project and we’ve developed a solution but hadn’t design any deployment system for getting the devices ready, so it was all manual work.

The solution uses the network through GPRS/Edge and each of the devices needed to have a cellular (GPRS) Line modem connection defined. Doing this on 20 devices by browsing to Settings -> Connections -> Add new modem connection, then add the same data for APN, username, password was just to much of a pain.

An easier way of doing this is to use the ConfigurationManager, found in the Microsoft.WindowsMobile.Configuration namespace. My purpose was to just make sure there was a cellular modem connection defined  with a working configuration. I wanted this to be the first to be done, and i wanted this to be re-run at application launch each time to reset any “mis”-configuration done by end users thorough the pilot period.

Firstly i defined a method that would give me a string with xml data. – This could also have been done a bit more elegantly or smooth, but it works for me this way.

private static string XmlConnectionString()
{
     string connectionName = "GPRS";
     string username = "";
     string password = "";
     string apnName = "Telenor";
     string myString =

     "<wap-provisioningdoc>" +
     "<characteristic type=\"CM_GPRSEntries\">" +
     "<characteristic type=\"" + connectionName+ "\">" +
     "<parm name=\"DestId\"" +
     " value=\"{ADB0B001-10B5-3F39-27C6-9742E785FCD4}\" />" +
     "<parm name=\"UserName\" value=\" "+ username +"\" />" +
     "<parm name=\"Password\" value=\"" + password +"\" />" +
     "<parm name=\"Domain\" value=\"\" />" +
     "<characteristic type=\"DevSpecificCellular\">" +
     "<parm name=\"GPRSInfoValid\" value=\"1\" />" +
     "<parm name=\"GPRSInfoAccessPointName\" value=\"" +
     apnName +"\" />" +
     "</characteristic>" +
     "</characteristic>" +
     "</characteristic>" +
     "</wap-provisioningdoc>";

     return myString;
}

Secondly I create my modem connection as the very first thing in the application Main method.

[MTAThread]
static void Main()
{
     try
     {
          XmlDocument configDoc = new XmlDocument();
          configDoc.LoadXml(XmlConnectionString());
          ConfigurationManager.ProcessConfiguration(configDoc, false);
     catch (Exception ex)
     {
          // Error Handling.....
     }
}

This was a quick and “dirty” way of doing it, and it saved me some time.

Use Facebook to Comment on this Post

When it comes to application development on the Windows Phone platform things are on the move. Lessons are being learned from the iPhone and its usability experience, from the Android platform etc. The lesson learned is that you need to pay extra attention to how your application looks and feel.

You should not under estimate the possibility of usability and design being the selling point in a purchase decisions before feature richness in a case  where two  similar featured apps are compared, where one looks and feels good, and the other has an extra amount of features beyond the core functionality it should handle.

As i am on the look out for a UI toolkit to standardize our enterprise development at work  on I´ll compile a list of libraries that could do the job as i find them. The criteria for the search is ease of use and finger friendliness. Hopeful others also find this list useful.

Fluid
Fluid is an open source ui framework that aims to mimic the IPhone ui controls. It is hosted by CodePlex and at the time of writing the current beta release is from February 15, 2009. It is released with a Microsoft Public License (Ms-PL).

Fluid is maintained by a single developer by the looks from the “People” list and i can´t find anything that shows continued work on the project. The issue tracker show some new registrations but it´s uncertain if they will be fixed.  My guess on Fluid is that it is a good starting point, and if you are after a iPhone look and feel it is a  good UI library to extend and do continued development on.

Fluid UI controls

A Open Source demo application called PasswordSafe that implements Fluid is available from CodeProject for download. The application also include support for Windows Mobile 6.5 gestures. Looking at the source code for PasswordSave i see that there first of all is no designer support. Secondly the application you create uses a “host” WinForm and then you create  screens in code and run these screens from the host WinForm. The idea is not bad, but if you are used to WYSIWYG UI design you could be in for a more “hardcore” development experience. The benefit of this is that you have more control of your own user interface.

Silvermoon UI controls

Silvermoon
Silvermoon is another open source ui control lib. It has some of the same properties and aims to do the same as fluid. But where Fluid was copying the usability from iPhone, Silvermoon tries to mimic the behavior of the Windows Mobile 6.5 today screen and sub controls with some extra features. Have a look at this demo of beta 2 on YouTube.

Silvermoon uses OpenGL as the rendering engine, and thus enables rich animations and transitions.

At time of writing Silvermoon is out in a beta version 0.92 released with a Microsoft Public License (Ms-PL) on October 4, 2009.

The development “style” of Silvermoon is the same as with Fluid. The reason for this is (i think) mainly that the same developers does both of the projects. How Fluid and Silverlight will continue the development is uncertain, both projects look promising… but it could be time consuming to wait for bugfixes and new releases since they have only one developer, Thomas Gerber.

I like his ideas, and to have a end to end control library that gives a Windows Mobile 6.5 look and feel that is consistent through the application is great. Silvermoon is a candidate for use. The desicion must then be to use and maintain the existing functionality and continue and extend it when we need to.

Resco MobileForms Toolkit

Resco advanced list

“Developer perfection combined with graphic designer creativity creates an unprecedented toolkit. The components and libraries are designed to eliminate hardware limitations of mobile devices, such as small screen or lower performance. A ground-breaking technology — seamlessly integrated in the components — offers multiple benefits to the developer community.”

That is the statement that awaits me at resco.net. Resco is the first commercial toolkit i am looking to evaluate.  Resco MFT can be purchased as Standard, Professional and Enterprise. with a price from $750 – $3000 USD. where Standard is a single developer license and the Enterprise is for unlimited developers at a single site.

The Resco controls looks like they offer great flexibility, and they support WYSIVYG in Visual Studio. An article detailing the strength of the controls can be found here. When it comes to the weaknesses i´ll have to come back to that. We have some developers using these controls out on client development and their feedback has been that the controls they use has flexibility and is easy to use.

SmoothListBox
SmootListBox is not a multi control library. It is a listbox implementation created by Fredrik Bornander that you navigate using your finger. The control is well explained through an article hosted on CodeProjet.

I´ve used this as a template for controls in several client solutions and i have found it is easy to implement and extend. Using this control you instantly get a new and look and feel to your application.  Theming the list into your application just makes it feels more smooth and professional…

Mirabyte Touch Control Suite

Mirabyte is a commercial control suite.  Their gallery display a nice set of useful controls that includes a TouchListBox control upporting finger based kinetic scrolling promising  to be very responsive and smooth, supports multiple screen resolutions, intelligent item selection and stylish transition effects with sliding animation to all four sides of the screen. A ButtonBar and TitleBar, a TouchPicturBox that has a built in (stepped) zoom functionality and supports smooth scrolling operations using the finger. A TouchPictureButton, a nice looking GlassDialog control that can be used as a  replacement for modal dialogs like MessageBox.Show(…); the background of the form is dimmed and either a generic dialog box is shown or a custom skin can be used (including alpha transparency!).  They’ve created a YouTube demo of the control features that can be viewed here.

The Mirabyte controls can be purchased at €70 EUR (There’s a special offer at €50 EUR going on (2010-01-15)  so if you are quick it still might be valid) .

beeMobile4
beeMobile4.net has a set of single controls that can be purchased off their website.  It’s not a complete suite, but a set of single controls that you purchase individually. A bit pricey for my liking but they have good looking controls. Each control costs around €40 Eur each.

Most interesting controls are the iWeel which allows the user to choose items from lists by rotating a cylinder. The items of the list are spread over the surface of the cylinder and behave much like iPhone’s date picker. The cylinder can be rotated by touching its surface and hence spinning it. The MessageBox which functionality is the same as the of the standard well-known MessageBox control. However, its stylish look, rounded corners as well as transparency give it modern and attractiveve design. The WaitingBar which informs the user of a lengthy background operation. It can operate as either a progress bar or a waiting bar. They also has a set of controls called TransparentControls that contains a transparent picturebox, checkbox, label, form image button and a control called a VistaButton. All of them looks quite nice.

Use Facebook to Comment on this Post

In this post i share what is my experience, and what i have found to work for me as a best practice for setting up my projects and software structure when developing windows phone applications in Visual Studio 2008.

Basically I am  applying some Model-View-Presenter principles tweaked for simplicity and dividing the different parts into separate projects.

The Model-View-Presenter software design pattern is in my opinion the easiest pattern to use. It is also easy to get going with if you`re not familiar with the jungle of three or four letter acronym patterns and support frameworks available.

Patterns are important and you should use them! By applying, in this case a MVP pattern we can easily handle the rapid changes in new hardware, screen form factors, UX requirements and connectivity requirements to back-end systems.

Other software design patterns exists and they can do the same thing and more, but the MVP pattern is simplistic, easy to understand and to implement. It also (if implemented correctly) ensures testability.

Model-View-Presenter pattern overview
As you will see later; each application form is a view. Each view sends and receives data through a presenter and the presenter is responsible for delivering the correct data required by the view. The presenter acts as a data broker between the back end model that communicate with back end databases and/or web services etc. and the front end view that is communicating with the end user.

The most effective implementation of this pattern is by creating a 1:1 mapping for object:interface. Meaning that for each view you have a view interface, for every presenter a presenter interface and for each model object there is a model interface.

There is no specific requirements regarding the use of application level events in this pattern besides that events must follow the data flow set in the design pattern. A model interface can expose events to be consumed by a presenter, a presenter can expose events for the view to consume, and the presenter can subscribe to events from the view.

Setting up the Visuals Studio 2008 solution
When you are setting up Visual Studio 2008 for development you do this with a base set of 4 core projects which will be the foundation of your application. By applying this layering you create a solution that is easy to maintain and extend, this is valuable if you should need to re-design the application for a different mobile form factor or screen size. And it would be easy to replace the concrete implementation of the model if you are to use a different communication platform in the application or different back-end database system.

The next section shows in detail how you divide your solution and what you place where.

Mobile.[ProjectName].MVP
The MVP project is created as a Library project type and is the skeleton for your application. In this project you create 3 subfolders named “Model”, “View” and “Presenter”.

My opinion on the best practice for naming conventions for interfaces is that every interface name should be prefixed with an upper case “I” to indicate that it is an interface.

There are different views on the topic of prefixing interfaces. The upper case “I”  is one opinion, another one, popular in the Java community is that you do not prefix interfaces and rather have an “impl” suffix on your concrete implementation classes. Example of this would be that you have a Login interface and a LoginImpl concrete class implementation, but I have found that prefixing interfaces makes more sense to me.

The skeleton project; Mobile.[ProjectName].MVP should NOT have any bindings to concrete hardware or software modules in code or thrugh references. This is to be implemented inside the concrete view or model projects.

Mobile.[ProjectName].MVP parts
The next section is a detailed explanation on how the MVP  skeleton is implemented.

Model
In the model folder you place interfaces for retrieving data and sending data to the backend domain, this needs to be generic and should contain data access factory interfaces, communication factory interfaces etc.

public interface ILoginModel
{
     Bool UserAuthenticated(string user, string password);
     SomeObject GetPreConditions();
}

View
In the view folder you place the view interfaces. There must be an interface for each main application form. Each view interface name should be named logically for its use with a naming pattern like I<function>View. For instance an interface for your login screen will be named ILoginView and product detail view should be called IProductDetailsView.

ViewData/SaveData and View requirements
A view will have some requirements for initial data upon presentation and also return some changed or processed data that it wants to deliver up the application stack.  It might have need of localized resources like language spesific label texts, it might need a list of data the user is to do a selection from, or it is the product details to display on a product details form. This is what we call “ViewData” and “SaveData”. These requirements are defined in a view interface using generics.

public interface ILoginView<TViewData, TSaveData> { … }

You do not need to define both view and/or save data. Define those your view requires. The advantage of this is that you can havecustom view/savedata for each concrete implementation of the view interface, giving great flexibility. The constraint is that the concrete implementation of your presenter needs to know what this “custom” view/save data is throughout its lifecycle.

We’ve found that defining a BaseViewData class inside the Mobile.[ProjectName].View namespace ensures that it is always available.

The BaseViewData class encapsulates everything that is a common requirement for all views. This could i.e. be a text source reader for language specific UI labels amongst others.
Inside the view interface file we create a concrete ViewData class for that specific view that extends the BaseViewData. The same can/should be done if there are common SaveData.

namespace Mobile.[ProjectName].MVP.View
{
     public interface ILoginView
     {
          void InitializeView(TViewData viewData);
          void UserValidated();
          void InvalidUser(string reason);
     }

     public class LoginViewData : BaseViewData
     {
          LoginView specific view data
     }

     Public class LoginSaveData
     {
          LoginViewspecific save data
     }
}

Presenter
The presenter interfaces defines the minimum requirements for the concrete presenter implementations.

public interface ILoginPresenter
{
     void Initialize();
     void AuthenticateUser(string user, string pass);
}

As we have designed it; it is not bound to a view or view interface.

The above explains how you create the “skeleton”,  next we continue with the concrete implementation of these interfaces.

Mobile.[ProjectName].Model
The model project is created as a library project and has a reference to the Mobile.[ProjectName].MVP project/assembly. Mobile.[ProjectName].Model is the concrete implementations of the Mobile.[ProjectName].MVP.Model interfaces. This module should handle all database operations and network and hardware I/O  in your application. The model project should not need to know anything about your presenter or view.

Public class LoginModel : ILoginModel
{
     Bool UserAuthenticated(string user, string password)
     {
          // connect to web service or database
          // check user credentials
          return (true|false)
     }

     SomeObject GetPreConditions()
     {
          // get some pre conditions and return them…
     }
}

Mobile.[ProjectName]
The Mobile.[ProjectName] project is created as a Windows Application and is the concrete implementation of the Mobile.[ProjectName].MVP.View interfaces. All code specific to this implementation should be placed here. This is the UI of the application.

public class LoginForm : Form , ILoginView<LoginViewData>
{
     ILoginPresenter _presenter = new LoginPresenter(this);
     Public LoginForm()
     {
          _presenter = new LoginPresenter(this);
          _presenter.Initialize();
     }
     public void InitializeView(LoginViewData viewData)
     {
          … Set up form data.
     }
     Private void LoginButton_Click(object s, EventArgs e)
     {
          // ask the presenter to validate user input….
          _presenter.AuthenticateUser(txtUser.Text, txtPass.Text);
     }
     public void UserValidated()
     {
          … Validated user can continue to work…
     }
     public void InvalidUser(string reason)
     {
          … Inform user about error…
     }
}

Mobile.[ProjectName].Presenter
The presenter project is created as a library project and references the Mobile.[ProjectName].MVP project. In this project you place all concrete presenter implementations. The concrete implementation of ILoginPresenter is in our implementation example bound to a login view interfaces and a concrete ViewData or SaveData class through its constructor.

Namespace Mobile.[ProjectName].Presenter
{
     public class LoginPresenter : ILoginPresenter
     {
          private ILoginView<LoginViewData> _currentView;
          private ILoginModel _currentModel;
          Public LoginPresenter(
          ILoginView&lt;LoginViewData&gt; view,
          ILoginModel model

          public LoginPresenter(ILoginView<LoginViewData> view, ILoginModel model);
          {
               _currentView = view;
               _currentModel = model;
          }

          Public void Initialize()
          {
               LoginViewData lvd = new LoginViewData();

               // populate the view data object if needed.
               SomeObject obj = _currentModel.GetPreConditions();
               Lvd.property1 = obj.property1
               ….

               // send the data required  by the view
               _currentView.InitializeView(lvd);
          }

          Public void AuthenticateUser(string user, string pass)
          {
               If (_currentModel.UserAuthenticated(user,pass)
                    _currentView.UserValidated()
               Else
                    _currentView.InvalidUser(“Unknown user”);
          }
     }
}

Other supporting projects
In addition to the above 4 projects you might have utility classes that can be shared amongst different implementations. This could be custom UI controls placed in a separate project for reusability communication libraries etc. They should be referenced and consumed in either your concrete model or view implementations.

Software Design Pattern Summary
From this pattern you see that there is constant communication between the presenter and the view and the presenter and the model. The concrete view is responsible for defining what presenter to use and tells the presenter what view is calling the presenter. The view then tells the presenter to start initialization, and the presenter informs the view by calling its initialize view method. The concrete presenter does not care where it gets its data from as long as it comes through a model interface, and it does not care about the inner workings of the view as long as its outer working environment is defined through the view interface.

We have now implemented testability.

This pattern could be extended even further; it is just a matter of finding the right layer of abstraction. For instance the ViewData and SaveData classes could have been interface based, more use of generics could have been implemented etc. but the preceding examples provides the layering we have found useful in our development projects.

Thoughts on code quality control
If you are ready to go this step into implementing a pattern that makes your code extendable, you should also think about how you code it and how you keep it bug free.

Coding conventions
I choose to follow the naming conventions found here: http://msdn.microsoft.com/en-us/library/xzf533w0%28VS.71%29.aspx, if you don’t like this one, find one that is commonly know and stick to it!

When naming methods, properties and variables make sure they are descriptive of what they do.  Descriptive property, method or variable names should make in-code comments obsolete.

There is no need to limit the amount of characters used for naming a method “GetListOfUsersFromNamedSource” is a descriptive name that explains what it does.

If your method name contains “and” in it; it indicates that your method does more than one thing and should be re-factored into two or more separate methods. One method should have one single responsibility.

Avoid “super methods”! If you have a method with an if/else block and each of the blocks contain 30 lines of code, re-factor into a method with an if/else block that calls two descriptive methods.

More pointers on how to improve code quality can be found in the book “Clean Code” by Robert C. Martin – http://blog.objectmentor.com/articles/2008/04/08/clean-code-whew. It is a great book.

Logging and Error handling
Log all errors! Logging of exception events shuld be done through log4net from Apache (http://logging.apache.org/log4net/index.html)

All developed code modules should implement and use log4net as a logging mechanism. In a try/catch/finally code block, the catch block should always log it´s exception to log4net as in the following example.

try
{
     .... do something
}
catch (SpesificException ex)
{
     log.Error("Unable to do something",ex);

     .... do error handling and/or push it up the stack.
}
catch (Exception ex)
{
     log.Error("Unhandled exception",ex);
}
finally
{
     ... do cleanup stuff
}

If any other log4net logger types are used; Debug, Warn and Info, i check to confirm that the used type is configured like the following example:

if (log.IsDebugEnabled)
     log.Debug("Some debug information");

if (log.IsInfoEnabled)
     log.Info("Some informational message")

if (log.IsWarnEnabled)
     log.Warn("Some warning message");

Testability
While writing unit tests i try to follow the principles found in the book “Art of unit testing” by Roy Osherove  – http://www.artofunittesting.com/

“A unit test is an automated piece of code that invokes the method or class being tested and then checks some assumptions about the logical behavior of that method or class. A unit test is almost always written using a unit-testing framework. It can be written easily and runs quickly. It’s fully automated, trustworthy, readable, and maintainable.”

The preceding MVC implementation is created with testability in mind and each module containing logical code must have a set of accompanying unit tests proving how it behaves within and outside the bounds of its specification.

Logical code is any piece of code that has some sort of logic in it, small as it may be. It’s logical code if it has one or more of the following: an IF statement, a loop, switch or case statements, calculations, or any other type of decision-making code.

Unit tests must be implemented using the Nunit testing framework (http://www.nunit.org/index.php)and each of the tests must be created as isolated tests with no external requirements. Meaning that you have to run test s“a”, “b” and “c“ in sequence, or that have a tests that require any other pre-conditions like access to databases, network etc.

When naming test, for clarity use the naming convention from “Art of Unit Testing”:

[Test]
public void [MethodUnderTest]_[Scenario]_[ExpectedBehavior]()
{
     .... test code
}

A sample sample MVP Visual Studio 2008 solution can be found here.

Use Facebook to Comment on this Post

Here´s a short how-to for getting started with gestures in your Windows Mobile applications. First how you set up your device project, and then i explain how it works using the managed gesture wrapper from MSDN.

First of all you need to consider if you would like to do it the “hardcore” way? by doing all the P/Invoke native calls yourself (then this documentation on MSDN is really useful) or if you just want to get gestures working and use the managed wrapper available in the MSDN code library, - You can also find the source code for the  wrapper there if you later need to find out how it really works. I haven´t  investigated the wrapper library yet, so I am not sure if it  encapsulates all the native functionality that is available.

First of all; Start Visual Studio 2008 and create a new device application solution. There is no specific Windows Mobile 6.5 application template so you just choose a Windows Mobile 6 project. Next you need to do is to add a reference to Microsoft.WindowsMobile.Gestures.dll (assuming now that you have downloaded the dll file) in your WYSIWYG in VS08.

1. Right click on the General tab in the toolbox and select “choose items…”
2. In the “Choose toolbox items” dialog select the browse button in the “.NET Framework Components” tab
3. Browse to where you extracted the Gestures dll file and select it.
4. A component called “GestureRecognizer” has it´s checkbox checked and selected.  Click the OK button.

If you look at your toolbox now you see that you have two new components. GestureRecognizer and PhysicEngine. These are non-visual components that you use in your application to interact with the native api’s.

Drag a GestureRecognizer component onto your application form and it is placed next to the default mainMenu1 component.  The GestureRecognizer component has very few properties and most important are the “Name” and “TargetControl”. You should name your component so that it reflects the target control you intend to “gesturize”. The TargetControl property has a drop down list with all components in your form. You will need to attach the GestureRecognizer to a component, or to the form itself.

The interesting part of the component is found when you view the events that GestureRecognizer exposes. The events are Begin, DoubleSelect, End, Gesture, Hold, Pan, Scroll and Select.

• Pan gesture is the event you want to use for moving things around with the finger in your UI.
• Scroll is triggered when you accelerate the pan, meaning that when a pan event occurs, and you move your finger in any direction a Scroll event is fired. The pan state has entered “Inertia”.
• Select is when you tap the screen.
• DoubleSelect is the same as a double tap.
• Hold fired when you tap and then hold your finger on the screen.
• Begin is as the name implies an event that is triggered at the start of any gesture.
• End is triggered when any gesture is ending.
• Gesture is a generic event that fires on all events.

Each of the event work in a familiar way and each event carries an Microsoft.WindowsMobile.Gestures.GestureEventArgs object that extends from EventArgs. Here are the properties from GestureEventArgs:

• .Kind gives you an enum with what type of gesture was triggered (Begin, DoubleSelect, End, Hold, Pan, Scroll and Select)
• .State gives you an enum value with the state of the gesture. The gesture state can be one of the following: Begin, End, Inertia or None.
• .X is the int coordinate from left
• .Y is the int coordinate from the top.
• .Location is a Point of X and Y

The exception from this is the Scroll event that gives you a GestureScrollEventArgs object that inherits from GestureEventArgs. The GestureScrollEventArgs object has some additional properties.

• .Angle of the scroll movement.
• .ScrollDirection is an enum value of either Up, Down, Left or Right.
• .Velocity is the speed of your moment as a number representing pixels per second movement.

The best way to see this in work is to add a label control to your form, resize it so it can contain multiple lines. Then try to subscribe to the ie. pan event. Inside the Pan event method you can add the following code:

private void gestureRecognizer1_Pan(object sender, Microsoft.WindowsMobile.Gestures.GestureEventArgs e)
{
     string outPattern = "{0}:{1}-({2}:{3})";
     label1.Text = string.Format(outPattern, e.Kind, e.State, e.X, e.Y);
}

If you then run this on your Windows Mobile 6.5 device or emulator you can see the tracking information from the event inside the label. Playing around with this is useful and you can add more events to try the interaction between them. When you are familiar with how it work it is much easier to use it in your later projects.

Use Facebook to Comment on this Post

It’s friday and time for some fun, and having a look at the gesture and physics engine of WM 6.5 qualifies as such . Googling for developer references i found that on august 26th and september 2nd 2009 Microsoft through Alex Yakhnin and Ron Buckton hosted two developer webcasts (level 400) on the gesture and physics engine of Windows Mobile 6.5.

This was a really useful intro on how to implement this your own .netcf applications. Gestures are supported in the existing standard ListView, Listbox, WebView, TreeView and Tab controls. and you get this characteristics just by running the application on a WM 6.5 device. But to programmatically control the gestures you need to handle the Select, Scroll, Pan, Hold and DoubleSelect events.

A detailed guide on how for the gesture apithis can be found on MSDN here. To fully understand this you need to be familiar with P/Invoke and native calls.

WebCast part 1
WebCast part 2
Download code samples and the managed gesture wrapper here.

Use Facebook to Comment on this Post

Norwegian online paper digi.no (Norwegain article) has an interesting article today about an anouncement from the open source project MONO. They have completed a SDK called MonoTouch. MonoTouch is the Mono edition for Apple’s iPhone and Apple’s iPod Touch devices.  MonoTouch allows developers to create C# and .NET based applications that run on the iPhone and can take advantage of the iPhone APIs as well as reusing both code and libraries that have been built for .NET as well as existing skills. MonoTouch also includes XCode integration.

MonoTouch is not open source and comes with some quirks when it comes to application distribution and licensing but it is a good step in the right direction.

MonoTouch comes in three version Personal for $399, Enterprise for $999 and Enterprise 5 for $3 99.

You are still (more or less) required to own a Macintosh to do development.

This is a great benefit for .netcf developers looking into developing applications for the Iphone without the pain of having to go through learning objective-c, the native iPhone application language.

The release is for the official version 1.0 of the SDK and more information can be found on the project website, including documentation and tutorials.

http://monotouch.net/

Now, together with redFiveLabs (http://www.redfivelabs.com/) and their wrapper for the Symbian OS, you theoretically can deploy the same code base to all of the major mobile platforms.

As soon as the trial edition is available i´ll have a go at it and see if it´s good for anything.

Use Facebook to Comment on this Post

Our goal was that we had a details screen for data with a button that would take you to a form with a list of selectable items. When an item was selected from the list, we wanted to show the selection in our details screen without having to send the data back into the dexterra business objects from the list screen, and then read the updated data from the database into the detail screen.

We were using Dexterra version 5.6.1 for our development and the solution we found was this.

We have two forms DetailsScreen and ListScreen inheriting from the Dexterra.Framework.Screen class.
Inside the ListScreen we have an public event named ListItemSelectedEvent and on the DetailsScreen we have a button named btnListSelection.

I am not going to show how the ListItemSelectedEvent gets triggered in this example,if needed i can post an update with the code.

First of all we need to create an ActionLaunch object. We solved this in our application with an FlowHander class.

FlowHandler flow = new FlowHandler();

We have a number of methods in this class. Returning the most common Action objects we use from the Dexterra framework, ActionLaunch, ActionDone, ActionExit, ActionBack. The one we need is ActionLaunch and we get it from the method GoToNewScreen:

public ActionLaunch GoToNewScreen(Component parentComponent,
                                             String target)
{
        ActionLaunch actionLaunch = new ActionLaunch();
        actionLaunch.EventHandlerTypeName = "actionLaunch";
        actionLaunch.FriendlyName = "actionLaunch";
        actionLaunch.InitiatorEvent = "Click";
        actionLaunch.ParentComponent = parentComponent;
        // CreatePocketPCSheet returns a configured
        // PocketPCSheet object
        // Not included
        actionLaunch.Target =
                   CreatePocketPCSheet(target);

        ActionFlow actionFlow = new ActionFlow();
        actionFlow.Actions.Add(actionItem);
        actionFlow.EventHandlerTypeName = "";
        actionFlow.FiringPattern = FiringPattern.None;
        actionFlow.FriendlyName = "actionFlow";
        actionFlow.InitiatorClass = null;
        actionFlow.InitiatorEvent = null;

        return actionLaunch;
}

In our DetailsScreen class we have a member variable for the ActionLaunch and our ListScreen;

private ActionLaunch _newScreenLaunch;
private ListScreen _listScreen;

In the Load method of DetailsScreen we create the ActionLaunch and subscribe to our button click event.

private void Form_Load(object sender, System.EventArgs e)
{
        btnListSelection.Click += btnListSelectionEvent;
        string newScreen = "projectname.ListScreen";
        _newScreenLaunch = flow.GoToNewScreen(this,newScreen);
}

DetailsScreen is the parent component (this) and newScreen is the full path to the screen to open. Dexterra will use reflection to add this to it’s stack.

Finally we have the event method for our button click where we perform the _newScreenLaunch action and get the ListScreen from the screen stack.

private void BtnChangeStationClick(object sender, EventArgs e)
{
        _newScreenLaunch.PerformAction();
        Host host =
            EngineCache.Instance[EngineCache.DEFAULT]
              .ScreenStack.Peek();
        if (IsTargetMyListScreen(host.TargetInstance)
        {
            _listScreen = (ListScreen) host.TargetInstance;
            _listScreen.ListItemSelectedEvent +=
                UpdateDetailsFormWithSelection;
        }
}

We perform the action – this puts our ListScreen on the top of the screen stack and trigger Dexterra action for opening the screen.We then retrieve it from our screen stack. Validate that it is a ListScreen we got before we subscribe to the event.

private bool IsTargetMyListScreen(Dexterra.Framework.Screen target)
{
        if (target == null) return false;
        if (target is ListScreen) return true;
        else return false;
}

and then subscribe to the event on the ListScreen.

    _listScreen = (ListScreen) host.TargetInstance;
    _listScreen.ListItemSelectedEvent +=
                   UpdateDetailsFormWithSelection;

When the ListItemSelectedEvent event fires – the UpdateDetailsFormWithSelection method is triggered and we update our DetailsScreen data.

I am still quite new to Dexterra but have not found any easier way to come around this, we also got pointers from Dexterra Central that this was the best way to do it.

What must be said here is that our application was created from code and code only, we did not use any of the WYSIWYG (What You See Is What You Get) Dexterra encourages you to use, since we found that building applications in drag and drop just doesn’t give you usable applications in any commercial form.

We created the application with a MVP (Model-View-Presenter) application pattern and used Dexterra as an integration and data access platform in this app.

Use Facebook to Comment on this Post