How to distinguish between a mobile phone and a desktop?

DanielKotzer

Hi,

I have an application which I want to look different on a desktop then on a mobile device, because a mobile device is usually held in your hand closer to your eyes, seen from a short distance, and you can have smaller UI components and text, but a desktop is sitting on your table, and you are sitting next to it, looking at it from a longer distance then a mobile device, as it is usually bigger, so the UI elements and font size of the text should be bigger.

With the help of members on this forum I did find how you can make the UI elements look bigger, by using RuntimeDPIProvider, but now the question is how can I set a condition that will give different runtimeDPI to different screen sizes?

Most examples of classes that extend the RuntimeDPIProvaider only take in consideration the Capabilities.screenDPI, including the original class in the Air SDK, but I want to have a different DPI for different screen sizes, which are probably made for a desktop. How do I do this?

Bellow is an example of a class that is taking in consideration not only the dpi but also the number of pixels of the screen, but I don't really understand the calculation it makes. I can't just use it as it is, because on my computer screen it has no effect, because I didn't set a very high resolution, my screen is only 1600 x 900, so I need to change the formula. I would appreciate any ideas on how I can determine the real size of a screen in inches?
Capabilities.screenResolutionX/Y doesn't help me because resolution of the screen can be changed, the same screen size can have many resolutions, and the Capabilities.screenDPI is not changing when I set a higher resolution on my screen, so how can I know the real size of the screen?

`package classes {

import flash.system.Capabilities;

import mx.core.DPIClassification;
import mx.core.RuntimeDPIProvider;

public class CustomDPIProvider extends RuntimeDPIProvider
{
	public function CustomDPIProvider () {
	}
	
	override public function get runtimeDPI():Number 
	{

		var screenX:Number = Capabilities.screenResolutionX;
		var screenY:Number = Capabilities.screenResolutionY;
		var pixelCheck:Number = screenX * screenY;
		var pixels:Number = (screenX*screenX) + (screenY*screenY);
		var screenSize:Number = Math.sqrt(pixels)/Capabilities.screenDPI;
		trace("screenSize: " + screenSize + " - " + Capabilities.screenDPI + " - " + screenX +"/"+screenY + " - " + pixelCheck);
		if (screenSize > 4.3 && pixelCheck > 510000 && pixelCheck < 610000 &&
			Capabilities.screenDPI < 240 && pixelCheck != 1296000) 
		{
			//trace("Force 240");
			return DPIClassification.DPI_240;
		}
		else if (screenSize > 6.9 && screenSize < 11 && pixelCheck > 610000 && pixelCheck < 1920000 && pixelCheck != 1296000)
		{
			//trace("Force 240 Tablet");
			return DPIClassification.DPI_240;	
		}
		
		if (Capabilities.screenDPI < 200)
			return DPIClassification.DPI_160;
		
		if (Capabilities.screenDPI <= 280)
			return DPIClassification.DPI_240;
		
		return DPIClassification.DPI_320; 
		
	}
}

joshtynjala

As I recall, the value Capabilities.screenDPI in Flash/AIR never changes on desktop operating systems. It seemed to be hardcoded to something like 72 or 96, depending on whether you are on Windows or macOS.

I did some research on this, and I recall learning this: until recently, desktop monitors didn't actually have a standard way to report their DPI to the operating system. I think that there are ways to do it with newer monitors today, but that only applies to those newer monitors, and older monitors still can't provide any useful information.

So that's probably why this is the way that it is in AIR. Even if AIR were using that newer way of detecting DPI, it would only be accurate in some cases, but not all.

Capabilities.screenDPI is really only useful on mobile, in my experience.

DanielKotzer

Yes I saw that on mac you always get a screenDPI of 72 and on pc 96, but really if all I want is to find out if it is a desktop computer, assuming that desktop computers have bigger screens, and assuming that if it is a mac or pc it is a desktop computer, then why not simply check the Capabilities.version?

bellow is an example of a class that changes the build in runtimeDPI only if it is a mac or pc:

package classes  {

import flash.system.Capabilities;

import mx.core.DPIClassification;
import mx.core.RuntimeDPIProvider;

	public class CustomDPI extends RuntimeDPIProvider
	{
	    public function CustomDPI()
	    {
	    }
	    
	    override public function get runtimeDPI():Number
	    {
		var TheSystem:String = Capabilities.version.substr(0,3); //IOS,AND,MAC,WIN
		if ( (TheSystem == "WIN") || (TheSystem == "MAC") ) 
			return DPIClassification.DPI_240;

	        return super.runtimeDPI;
	    }
	}
}

lokus

Since you have 2 export targets (desktop & mobile), you could set a variable during export, explicitly tagging the outcome as mobile or desktop.
I think something like compiler constants can be added during build process and used in the application logic.

2dguy

To answer the exact question in the op...

if(Capabilities.cpuArchitecture=="ARM" || Capabilities.cpuArchitecture=="ARM64")
{
  // mobile app
}
else
{
// desktop app
}

pol2095

Windows, macOS and Linux can be ARM too.

2dguy

yah.. I'm way behind.. lol.. I was looking at yearssss old routine. Has capabilities .cpuArchicture added any specific definitions for mobile only?

General

I find the device diagonal using this:

var inchW:Number = stage.fullScreenWidth / Capabilities.screenDPI;
var inchH:Number = stage.fullScreenHeight / Capabilities.screenDPI;
var deviceDiag:Number = Math.sqrt(inchW * inchW + inchH * inchH);
trace("diag=",deviceDiag)

It gives slight discrepancy from the real device diagonal, but it works for my needs

@2dguy glad to see you again! Were you able to set your FD environment? How did your house survive the winter freezes? Please DM