Develop Reference

Same screen specs but ADB reports different pixel density depending on OS version (LDPI/MDPI)

I suspect that later versions of Android OS are forcing MDPI rather than using LDPI. It would be helpful if someone could point me toward info/technical terminology on the exact change in the OS.
I have 2 devices with the same screen resolution and screen size, and the device models are nearly identical. It's a smaller, kind of obscure manufacturer, though that's probably irrelevant. One device is Android 6.0 and one is 8.1. Calculating pixel density from resolution and screen size, real-world pixel density should be about 141 pixels/inch, which would fall in the Android classification of LDPI.
The older OS seems to use LDPI and the newer one seems to use MDPI. This is based on observation and calling adb shell wm density.
Can anyone point me toward what changed in the OS? Thanks!

Preparing apps for the nexus 10

I am working on an android Audio Recording application, our app is currently designed to work on all android phones, the Nexus 7 and the Motorola Xoom tablets.
I was wondering if there are any guidelines or best practices to re-design/modify our app for Nexus 10. More specifically, any pointers on the below points would be really helpful:
UI guidelines to support the new 2560x1600 resolution
Android resource files related modifications (based on similar guidelines)
Any sample or open sources apps that have been modified to work on the nexus 10
Best practices creating and running a nexus 10 emulator since there is no such AVD device by default (screenshot below). Any thoughts on creating one, keeping the high resolution in mind.

As long as you have xhdpi assets, and layouts made for 10" tablets, you shouldn't have to do anything (except add a new xxhdpi launcher icon, as #Mattias mentioned).
To make a Nexus 10 AVD, navigate to Device Definitions:
Then, click New Device. Fill it out something like this:
Now it will be listed in the devices drop-down that you show above.

Regarding your second point, resources:
While the nexus 10 is a xhdpi device, it will use the launcher icon from xxhdpi "one bucket up" if available, so make sure to provide one as it will look much better/clearer/sharper. Reason is that there is room for a bigger icon on this device. Launcher icon size at xxhdpi is 144x144 pixels.
For reference see:
https://plus.google.com/118292708268361843293/posts/ePQya3KsTjW

The best way to emulate the Nexus 10 is to use AndroVM. I am currently running Android on it with the full Nexus 10 2560x1600 resolution and it fits onto my HD screen if I set AndroVM to use 320dpi.
Oh.. and it's VERY fast :-)
I personally use it over emulators and real hardware devices as it's extremely responsive and the deployment of the APK is lightning fast.
I do not contribute to the AndroVM project myself by the way, but it has speeded up my own development cycle considerably. In all development cycles, a developer waiting to see if their code tweaks work using an emulator or a hardware device adds considerable time overhead. I would thoroughly recommend using AndroVM regardless of screen size during normal code development.

Is it OK to develop on a mid range android phone?

I want to begin development for mobile and android seems like a good choice (with iphone requiring a mac and WP7 not being that popular).
I have a question regarding the testing platform, I'm pretty low on cash and have been wondering if using a mid range phone would hinder my development? I have the ability to buy either a LG Optimus One, a Motorola Milestone or a Nexus One, all representing different segments of the market and each one costing more than the previous.
two concerns I had were screen resolution and CPU power, how much does these two variables matter to development?

Well:
Resolution - there are 3 main groups:
ldpi - Low Density - devices with screens 240 x 320,
mdpi - Medium Density - 320 x 480,
hdpi - High Density - 480 x 800, or 480 x 854.
Of course the bigger screen == the more expensive phone.
2 . CPU power - all currently available CPUs (besides a few low-end phones) will propably serve you well (of course, it depends on what do you really want to do)
I, as a developer, would like to add here a third element - which API level (version of Android) are you targeting? Nowadays, 2.1 - 2.3 rocks, and 3+ if the device is a tablet.
Keep in mind, that if you buy a great phone, you may develop application which will be running quite fast on it, but it will not on other low-end devices. Btw, you can always check if all elements will properly layout on the lower screen using built-in emulator(s). So, in my opinion, there is good to have mid-end phone, just to check sth(s).
PS : Nexus one - AFAIK this phone is a debug version (means you can do a little more than with a standard retail phone :) ).

If you can buy a Nexus One that will serve perfectly. Obviously it doesn't cover every form factor but its BETTER than a midrange phone.
If you come across issues on a specfic device you can always use a cloud debugging service like:
http://www.perfectomobile.com/ (they used to have 2 hours free when you register)
You can emulate the different screen sizes
CPU power depends completely on what you are coding, but most the time you should be ok.
Me Personally I've got:
a Nexus One running 2.3
a HTC G1 running 1.6 (flip out keyboard formfactor)
I also use perfecto for issues with the SonyErricson X10mini (ldpi)
I emulate Honeycomb 3.0 on the PC (altho hoping to buy a XOOM soon).

Putting on my MBA hat: From a product development perspective it's probably a good idea to make sure your product runs on the widest product segment of whatever platform you're developing for. If that happens to be a mid-range product, your development efforts are probably aimed at the largest market segment and potential customers might be more likely to own/purchase this device. Even better if there's a common platform across all segments. You should probably perform some sort of market analysis to prove this out.

How can I distinguish phone from tablet

Using Adobe AIR for Android, I'd like to find a way to distinguish a phone from a tablet. The closest I can find is detecting the dpi. (My phone dpi is 254, my tablet is 149) but is that going to be reliable or is there a better way?
(I've been using stackoverflow for a while but this is my first post - yippee!!)

but is that going to be reliable
Absolutely not. A T-Mobile G1 would be a tablet by that measure.
is there a better way?
Frankly, you should not be caring whether an Android device is a telephone, tablet, television, toaster, telescope, or toilet.
You should be caring about characteristics and capabilities.
For example, if you are thinking about tablets in terms of screen size, use <supports-screens> and the -large and -xlarge resource sets (e.g., res/layout/ for normal stuff and res/layout-large/ for larger screen sizes).
Or, if you are thinking about tablets in terms of whether or not you can place a phone call, use <uses-feature> and hasSystemFeature() on PackageManager.

Whether a device is a tablet or not could mean...
One.... Is it running the Honeycomb tablet version (Android 3.0) ? You can use System.getProperty() to get this information.
or
Two....Is it tablet sized? i.e. is the screen a larger size? But bear in mind some tablets are not that big. Best way to handle these is separate resources for each device size.
I'd say in general it's a bad idea to try to define Android tablets into specific groups, as there are many varieties now and a LOT more are coming. So usually best to build your app so it handles different screen sizes, different OS versions, and different features being available or absent (e.g. GPS, keyboard etc).

cdotspace, don't worry about the real dpi, you only need to get virutal dpi:
int virtual_dpi=webview1.getResources().getDisplayMetrics().densityDpi;
Virutal dpi means dots per virtual inch.
For example, the htc desire hd's real width is 2.21 inches, but its virutal width is still 2 inches, the galaxy tab 10.1's real width is 5.35 inches(portrait orient), but its virtual width is 5 inches.
int portrait_width_pixel=Math.min(this.getResources().getDisplayMetrics().widthPixels, this.getResources().getDisplayMetrics().heightPixels);
int dots_per_virtual_inch=this.getResources().getDisplayMetrics().densityDpi;
float virutal_width_inch=portrait_width_pixel/dots_per_virtual_inch;
if (virutal_width_inch<=2)
{//is phone
}
else
{//is tablet
}

Which layout will use a 10,1" 1024x600 tablet?

I want to make sure that devices with 10,1" and 1024x600 under 2.1/2.2(e.g. Archos 101) are using the correct layout.
Are they large and ldpi?
Also, how can I simulate them using the android emulator?

In the end, the choices of screen size and screen density are up to the manufacturer. Hence, nobody here can answer you definitively.
A 10.1" diagonal screen should be large and probably should be ldpi, though it is possible it will be declared mdpi based upon the apparent density given the distance one would typically hold a 10.1" tablet from one's face.
Bear in mind that ARCHOS' devices do not ship with the Android Market AFAIK, and hence do not necessarily pass the various compatibility tests. As a result, ARCHOS could do all sorts of stuff that would be unexpected.
Also, how can I simulate them using the android emulator?
The Android SDK is not well-suited for testing a 10.1" LCD at this time. I would expect better instructions and support for such sizes in Android 3.0.
For now, set the resolution and density for the AVD when you create it. In this case, you would want to specify 120dpi (ldpi) for the density. Android should put it in the large screen size bucket for you, given those values. Leastways, that basic approach works for getting large WVGA devices.