Tech Blog

Jay's Technical blog

Intradynamics, LLC: Open For Business (again)!!

01 October 2011
Jay Kimble

[WARNING! This is an archived post and as such there may be things broken/missing here.. you have been warned.]

I just wanted to throw out a quick post letting the world know that I went independent again. Today is the first day in my business’ new start! I’m totally psyched! I’m going to be doing a variety of things: Silverlight (of course), Mobile, ASP.NET, and Javascript (aka HTML5 aka Ajax/Web2.0 aka DHTML… etc.). (and this is just my plan for the first week <grin/>).

One word of warning, I will be interspersing some content in here that isn’t purely Silverlight (and yes, this blog is about to be back in full motion again.. well, I hope so). I will try to keep the content pertinent to Silverlight though (but some of this stuff might be just off the corner.. for instance I have an upcoming Orchard CMS post coming very soon).


The Perf Tweak to my WP7 App that turned it from &ldquo;ho hum&rdquo; to &ldquo;Wow!&rdquo; (it works in Silverlight3+ OOB too)

01 October 2011
Jay Kimble

[WARNING! This is an archived post and as such there may be things broken/missing here.. you have been warned.]

[If you are in a hurry then the answer is CacheMode=BitmapCache. If you want to read the story/know more then read on]

I have been working on a Windows Phone 7 comic book reader over the last couple months. It’s actually done and has seen a few revisions. During the testing of my original release, my friend (and fellow member of the Florida WP7 developer’s club) Brian Kassay suggested that I should use a different library for my image gestures.

You see when you are viewing a comic book page with my reader you are actually looking at a single image which you can move around on the screen as well as can zoom into/out of, and change pages. The page/image viewer was really sluggish on the device. Brian thought it was the gesture library I was using, but nope. after wiring up a different library (the same one Brian uses), the performance was absolutely identical. No change whatsoever.

After listening to a bunch of performance podcasts and finally got my head wrapped around the problem. I turned on redraw regions (which is another tip I can give you), and saw that my image was re-rendering everytime I touched it with my finger (panned it around the screen)

Back in the Silverlight3 timeframe Microsoft added the ability to create an out of browser app that takes advantage of GPU Acceleration.. One of the things that surrounded this feature was a little property that I had totally ignored: CacheMode. I kind of thought the whole GPU acceleration thing was more about building games and ignored the topic. BUT, GPU Acceleration is on by default in WP7 (and I don’t think there is a way to turn it off). It’s on because guys at Microsoft knew we would need to take advantage of the GPU in WP7 apps more often then in standard Silverlight apps (because we are dealing with a CPU-limited phones). So, I switched this property from the default to “BitmapCache” on my image which was rendering constantly. Instantly I went from slow to fast when panning/zooming the image.

You may be wondering “should I turn this on for everything thjen?" Just cache the entire LayoutRoot?” Well, MSDN suggests to “Set the CacheMode property when you need to increase performance for content that is time consuming to render.” CacheMode=BitmapCache simply causes the element it is applied to to render a single time. The resulting Bitmap is cached and re-used for later render cycles (this is probably taking up some memory somewhere). This is great to use on elements that to don’t animate. I would suggest that you look at your WP7 UI and turn on redraw regions. Watch your app you will see what is rendering excessively. Try setting the CacheMode on these elements and see if your performance increases.


Silverlight/WP7 tip: Detecting when in VS Design Mode

01 October 2011
Jay Kimble

[WARNING! This is an archived post and as such there may be things broken/missing here.. you have been warned.]

I have struggled with dealing with this for sometime, and ultimately gave up. Today, I happened across something interesting. I’m doing some intense Isolated Storage stuff with WP7, and I’m using ViewModel. I analyzed one of the errors I was getting in the VS XAML designer, and discovered what in my ViewModel VS didn’t like. So here’s what I discovered.

The Technique

You can detect Visual Studio Design Mode by checking isolated storage. It throws an error when you try to access it from within Visual Studio. This is immensely useful when working with ViewModels that you are instantiating in either XAML or CodeBehind or even some kind of locator class. I wrote a little class in the vein of some of the code in MVVM Light (hopefully I can get Laurent to add this to the next version).

using System;
using System.IO.IsolatedStorage;
namespace AmazingPocketComicsViewer.Model
{
publicclass VSDesignDetector
    {
staticbool? isInDesignModeStatic = null;
publicstaticbool IsInDesignModeStatic // Convenient method that can be accessed out of an inherited class
        {
            get
            {
if (isInDesignModeStatic.HasValue)
                {
// only do the check once and use the last value forever
return isInDesignModeStatic.Value;
                }
try
                {
                    var isoStor = IsolatedStorageSettings.ApplicationSettings.Contains("asasdasd");
                    isInDesignModeStatic = false;
return isInDesignModeStatic.Value;
                }
catch (Exception ex)
                {
// Toss out any errors we get
                }
// If we get here that means we got an error
                isInDesignModeStatic = true;
return isInDesignModeStatic.Value;
            }
        }
protectedbool IsInDesignMode
        {
            get
            {
return IsInDesignModeStatic;
            }
        }
    }
}

And that is it! Enjoy!


Solving the Storage Problem in WP7 (for CF Developers)

01 October 2011
Jay Kimble

[WARNING! This is an archived post and as such there may be things broken/missing here.. you have been warned.]

There are a couple apps I would like to write for Windows Phone 7 that don’t currently exist right now. One of which is a Z-Machine emulator (that would be the same engine used in the Infocom text adventure games like the Zork Trilogy). The problem is getting files onto the device. You can’t sync them from the Zune software. You could create a browser to a site and then download the files that way (but sites tend to change).

If only there was a way to take advantage of some kind of custom user storage, but the average user really isn’t technical enough to manage a web server, etc. I have been searching a solution to this problem and I now have a solution to the problem.

I decided that I needed to go ahead and release a test version of my DropBox Client. You can get a compiled version here - http://sharpdropbox.codeplex.com/

I have tried a few others (WP7 Drop Box Clients) and none really were far enough along for me to use. Mine really needs some good testing, but it is far enough along that you can probably use it for browsing a user's DropBox folders/files and can download/open files from there (and they end up on the device in Isolated Storage).

It uses Isolated Storage for a file cache and it also caches the calls in a SterlingDB instance (also living in Isolated Storage). The only thing I haven’t fixed/tested yet is it needs to detect that there is no network and it then needs to use the SterlingDB for everything (skipping network calls).

I am at the point where I was last trying to implement Delete and Upload (upload keeps failing, so I have given up on that for the moment).

I'm may end up implementing a couple of these types of services and creating some kind of loose wrapper/interface around them so you could let the user choose his/her preferred repo. I really wish SkyDrive was accessible through an official SDK in WP7.


Service-Related APIs and Synchronous/Asynchronous Calls

01 October 2011
Jay Kimble

[WARNING! This is an archived post and as such there may be things broken/missing here.. you have been warned.]

I have a small rant today. It relates to APIs that consume some service like Facebook or Dropbox (the latter being the one on my radar).

Some Service Call Guidance

When calling a service directly, you want to use asynchronous methods in all but one case and that one case is during the processing in a web process or a Service (so within an MVC Actrion or Web Form page process, or during processing within your own service). In all other cases that I can think of you want to use Asynchronous calls; these include JavaScript running in browser, Silverlight in or out of browser, Windows Forms app, WPF app, and WP7 application. This is because you keep the app responsive. You can even go so far as to provide a way for the user to cancel a call, but regardless the user can continue using the app while data is being retrieved.

Now the Rant

If you have created a set of APIs that work synchronously retrieves data or makes a service call, this will work with a number of the scenarios I outlined above where I suggested asynchronous was the preferred way (for instance WinForms, WPF, JavaScript all have mechanisms to do Synchronous). But don’t do this. First of all when you go to support Silverlight you will quickly discover that Synchronous calls don’t exist. There are some hacks you can use, but from my experience they make the app unresponsive (and buggy) while calls are happening (so DON’T DO IT!). In fact when I see those hacks it makes me think that you don’t understand Async (and I don’t want to feel that way).

In some places I have seen where someone has turned the callbacks into events (so you call the api, and get events to fire). This isn’t terrible, but it assumes that I will always want to do the same thing every time a call comes back. You are better off not doing this.

I thought I would show you how to turn a synchronous call into an asynchronous one with minimal effort on your part. Well, you still will need to wrap your head around something like HttpWebRequest, BUT my advice here will help you make it a snap to add Asynchronous callback methods.

My Preferred Signature

First off, I want to show you what I personally like to see (and will give you a couple examples):

publicinterface iCallbackExamples
{
// Standard mechnaism that MS APIs typically give you
   ServiceResultObject CallSomeServiceSync(
int param1 // Insert your service paramters here
    );
// Standard mechnaism that MS APIs typically give you
void CallSomeServiceAsyncMSWay(
int param1, // Insert your service paramters here
         Action<ServiceResultObject, object> callback, // success callback
         Action<Exception, object> errorCallback, // error callback
object state // this is some variable that help you keep track of the call
// state is the "object" parameters in the Action callbacks
     );
// DevTho's preferred variation (with state) of an Async call
void CallSomeServiceAsyncWithState(
int param1,   // Insert your service paramters here
object state, // this is some variable that help you keep track of the call
// state is the "object" parameters in the Action callbacks
      Action<ServiceResultObject, object, Exception> callback // callback
     );
// DevTho's preferred variation of an Async call
void CallSomeServiceWithoutStateAsync(
int param1,   // Insert your service paramters here
        Action<ServiceResultObject, Exception> callback // callback
     );

											
											
// variation that I can live with
void CallSomeServiceAsyncAlternateWithState(
int param1,   // Insert your service paramters here
         Action<ServiceResultObject, object, Exception> callback, // callback
object state, // this is some variable that help you keep track of the call
// state is the "object" parameters in the Action callbacks
     );
}

BTW, this is all just to give you an idea of what I think is an acceptable signature. I often don’t use any kind of state object because I typically use an inline anonymous functions (aka Closures), so when I get a callback my local values are all intact and any class level changes have also taken place. (this let’s me return from a call, check the class’ state to see if the data is still valid or not). That callback action will vary depending upon what else I might need back. I have for instance returned the calling parameters in the callback and I will use those as a state check.

Here’s what a call of mine might look like using the “CallSomeServiceWithoutStateAsync” method:

void needsData(int param1) // Sorry Stan Schultes only a C# example.. someday I will create an auto convertor for my blog..
{
this.currentParam = param1;  // class level field value that we'll use to make sure that the request
// that is returning matches what is currently being requested (Async calls might return out of order)
    var someLocalValue = true;
    MyServiceHandler.CallSomeServiceAsyncWithoutState(param1, (result, error) =>{
// See we are handling the request inline (so this is a closure, it holds the original value of the someLocalValue and can
// see the class level variable
if(error == null)
         {
// we have data but is it the data we want
if(this.currentParam == param1)
            {
// there might be 2 requests going on because one was taking too long
// during that time the user might have clicked on something else, so now
// we need something else.

											
											
// Put the data some place or process it, etc. In Silverlight/WP7 you would
// Typically be putting this data into a class-level property that is data bound
// to the XAML. In that case you would need to use the Dispatcher (aka the UI thread)
// to do this.
            }
         }
else
         {
// Do something with the error here
         }
      });
}


 

I wll do a part 2 to his post (shortly to show you how to easily implement Asynchronous from your synchronous calls). Stay Tuned.