The other day I was looking at the Google Analytics data for my Windows 8 app and discovered that almost 5% of my users were running a resolution of 1371.42858886719 x 771.428588867188. Huh!?
The bad news is, this was due to a bug in the Google Analytics SDK for Windows 8 and Windows Phone — which I wrote! 🙂
The good news is, I have since fixed it, learned a lesson (that I should have already known), and can now share my findings with you.
The point of this post is to walk through the subject of detecting physical screen resolution from within your Windows 8 and Windows Phone apps. Although not terribly complicated, it is slightly more involved than you might expect. The cruxes are 1) there is no single API to query the size of the screen your app is running on and 2) you need to understand how a certain magical feature called scaling works.
First, what not to do:
You might be tempted to determine screen resolution via the following mechanisms…
For Windows Phone 8:
Size resolution = new Size(
Application.Current.Host.Content.ActualWidth,
Application.Current.Host.Content.ActualHeight);
For Windows 8:
Size resolution =
new Size(Window.Current.Bounds.Width, Window.Current.Bounds.Height);
The problem with this code (there are actually 2 issues for Windows 8 but I’ll get to that next) is that it doesn’t account for scaling.
Scaling is an awesome feature built into the platform where the OS attempts to stretch everything on the screen so an app will display at an ideal and consistent DPI regardless of the physical screen size and resolution. It does this by fooling the app into thinking that it’s running at a lower resolution than it actually is, but internally scales everything up to the real resolution before showing it on the screen. Also important to know: assets will not lose quality when they have more pixels than the pre-scaled size (this will make sense after my example below).
An example of scaling:
Let’s take an example of a 10.6” 1080p monitor (note: this is one of the screen resolutions you can set the Windows 8 simulator to).
Because this resolution is fairly high but the physical screen size is fairly small, Windows will automatically enable scaling and fool your app into thinking it is running on a lower resolution monitor. To re-iterate, this is a good thing because it means you as a developer or designer don’t have to worry about your UI looking really tiny on this particular device. To your app, the dimensions of the app (as reported by the APIs above) will actually be 1371.42858886719 x 771.428588867188 and so fonts and icons and shapes, …etc in your app will conveniently layout nicely and end up appearing at a similar size and position as it would on a 10.6” 720p monitor. Scaling gives you this little gift for free without you as the developer writing special code to change font sizes, …etc depending on physical screen DPI.
Avoiding pixilation!
I won’t get too much into the weeds about pixilation or best practices but I feel obligated to discuss 2 important things:
1) If you build your UI using a vector language (Xaml & HTML are vector languages), Windows and Windows Phone will be able to scale your UI to get the most out of every pixel without pixilation. Your app doesn’t need to do anything extra; scaling will automatically occur when visual elements are rendered and every pixel will be used. Learn more about vector graphics if that doesn’t make sense.
2) Assets like images and videos will automatically scale to fit the final resolution, not the fake application resolution. This one might be a little counter-intuitive. Imagine the following Xaml to display a 300×300 image:
<Image Source="/img300.png" Stretch="Uniform" Width="214" Height="214"/>
Because we set the width and height on the image control explicitly, your first impression might be that the image will always be stretched (Stretch = Uniform after all) to 214×214. The correct answer is: it depends.
If Windows has determined not to scale (because your monitor and resolution are close enough to the ideal DPI), then yes, the image above will be shrunk down to 214×214 when displayed on the screen.
However, if Windows scaling is occurring (lets assume at 1.4x), the image will actually be displayed on the screen in it’s full 300×300 glory. (214 * 1.4 = ~300)
To prove it, here are 2 images I created in Photoshop from the same vector source. One is saved at 214×214 pixels and the second is saved at 300×300 pixels. Using the following Xaml:
<StackPanel Orientation="Horizontal" Background="White">
<Image Source="///img214.png" Stretch="Uniform" Width="214" Height="214"/>
<Image Source="///img300.png" Stretch="Uniform" Width="214" Height="214"/>
</StackPanel>
When scaling is turned off (1x scaling):
Notice, the images look identical. This is because Windows will shrink the 2nd image (300×300) down to 214×214 before displaying it on the screen just like the Xaml says to do.
When Windows is scaling at 1.4x:
If you look closely, you can see that the second image is crisper. This is because the 300×300 pixel image is actually being displayed on the screen at 300×300 pixels despite what our Xaml’s height and width say will happen. The first image is actually being stretched to 300×300 when it is rendered to the screen.
Back to detecting resolution. And the correct answer is…
Easy, simply get the scaling factor (accessible via an API) and multiply it by the dimensions we gathered earlier.
For Windows Phone 8:
var content = Application.Current.Host.Content;
double scale = (double)content.ScaleFactor / 100;
int h = (int)Math.Ceiling(content.ActualHeight * scale);
int w = (int)Math.Ceiling(content.ActualWidth * scale);
Size resolution = new Size(w, h);
For Windows 8:
var bounds = Window.Current.Bounds;
double w = bounds.Width;
double h = bounds.Height;
switch (DisplayProperties.ResolutionScale)
{
case ResolutionScale.Scale140Percent:
w = Math.Ceiling(w * 1.4);
h = Math.Ceiling(h * 1.4);
break;
case ResolutionScale.Scale180Percent:
w = Math.Ceiling(w * 1.8);
h = Math.Ceiling(h * 1.8);
break;
}
Size resolution = new Size(w, h);
Almost there, don’t forget about snapped mode and orientation.
…I warned earlier that there was a 2nd problem with the Windows 8 code at the top.
For the Windows Phone, you actually don’t have to do anything. There is no such thing as snapped mode on the phone and Application.Current.Host.Content.ActualHeight and .ActualWidth always return values as if the app is running in portrait mode (even when it’s landscape).
For Windows 8, you do need to account for both snapped mode and orientation.
To help with this, you can compensate based on the ApplicationViewState. For example, here is the code I use to calculate the actual screen size, even when in portrait mode or filled mode (filled mode is when another app is in snapped mode next to your app).
if (ApplicationView.Value == ApplicationViewState.FullScreenLandscape){
resolution = new Size(w, h);
}
else if (ApplicationView.Value == ApplicationViewState.FullScreenPortrait)
{
resolution = new Size(h, w);
}
else if (ApplicationView.Value == ApplicationViewState.Filled){
resolution = new Size(w + 320.0 + 22.0, h); // add the width of snapped mode & divider grip
}
The only thing lacking here is detecting the screen size when the app is snapped mode. While this bothers the purist in me, I find that most users don’t start apps in snapped mode so as long as you get the resolution at the beginning of your app’s lifetime and remember it, 99.9% of the time you will be able to accurately determine the actual screen resolution.
Worthy of mention…
Apparently it is possible using DirectX and C++/CX to determine the actual screen size. I haven’t tried this for myself but there is a blog post on how to detect screen resolution from a C++ WinRT component here.
Additional resources
Guidelines for scaling to screens (Windows Store apps)
Programmer Payback 