monline

Let me warn you in advance: this is not going to be easy. If you're afraid you might brick your phone/tablet, don't even start. That said, it's really not too hard either. You just have to be the tinkering type and it doesn't hurt if you already know your way around flashing a custom recovery ROM, using ADB, etc.

First of all, the problem. Developers/publishers can set a few rules on their apps regarding device compatibility. These are more or less the following:

• OS version (ie. API level)
• screen size (7", 10", ...) / pixel density
• OpenGL version
• various capabilities/features (camera, gps, etc.)

Most apps have only a few rules (ie. Android version), but some have specific requirement for screen size and/or pixel density (ie. dpi). For further details on the latter, you can read the description of the <supports-screens> manifest element or the best practises for supporting multiple screens.

Most of these rules are checked via reading properties that you can set in a file on your device. It's the famous build.prop which resides in the (by default) read-only /system directory. So first of all you'll need a rooted device. If you got that, you'll have to create a backup of your original build.prop and I suggest you do this both on your SD card (eg. /mnt/sdcard/MyBackups/build.prop.orig) and on your system partition (eg. /system/build.prop.orig). It cannot hurt to have two backups, right?

Once you've a backup, you can always revert to it in case of failure. Of course this "reverting" can be a bit tricky since messing up build.prop can make your device fail to boot up. If this happens (and why would it not), you'll need a proper recovery ROM/image installed on your phone's recovery partition. Eg. ClockworkMod provides an ADB daemon that you can use to access the phone's system partition (while it's in recovery mode) and restore the original build.prop.

If you've all this in place (and tested it!), you can start thinking about messing things up. One thing should be clear though (although it's kind of obvious): changing system properties in a file won't give your device new capabilities. So even if you manage to install an app via Play Store using this hack, the app might not run correctly. This technique helps you only in case the developer defined too strict restrictions on the app and in fact it could work on a wider range of devices (possibly including yours). I used it to buy and install the HD version of one of my favourite games. Unfortunately the compatibility restrictions of the HD version were a bit too strict (and this was a known and not yet fixed issue!) and Play Store told me that the game was was incompatible with my phone, although it was fully capable of running the game. I did want to use the HD version and expected that the app compatibility would be fixed in an upcoming version, so using this hack I was able to buy and install.

To change the relevant build.prop entries, you'll need an editor.
Either you can just fetch build.prop via ADB, modify it on your PC and push it back ... or you can use a build.prop editor app (which is a lot easier/faster if you're regularly changing properties). There're quite a few on Play Store, I usually stick with Benjamin Wulfert's BuildProp Editor (note that the latter is no longer being maintained, but Benjamin has open-sourced it so if you're up to it, you can always fix+compile a version for yourself that is compatible with the recent Android releases).

Now comes the real work. First you've to find a device that is supported by the given app you'd like to get from Play Store. You can use the user reviews for this, there'll be most probably plenty of reviews about successful setups.

Then you've to find the relevant build.prop entries for that device. Usually googling for the device's name and the build.prop ro.product.model ro.product.manufacturer strings you'll get lucky.

In the first run you can try setting just these two properties (ro.product.model and ro.product.manufacturer) and see if it works for you. After having set them, I usually reboot (although this might not be necessary at all ... I haven't tested this yet) and clear both cache and data for the Google Play Store app. Then I start Play Store and see if it let's me install/buy the app I wanted.

If it doesn't work, you can try a few other properties:

• ro.product.brand
• ro.product.name
• ro.product.device
• ro.product.board
• ro.build.product
• ro.build.description
• ro.build.fingerprint
• ro.build.characteristics

Be careful never to change the ro.board.platform property!
If you change it to something incompatible (eg. your device has an OMAP4 chipset and you change the platform to tegra), your gadget will most likely not boot and you'll have to revert this from recovery mode.

Besides the above properties there's one more that is quite significant in regard to Play Store: ro.sf.lcd_density

As I already mentioned: app developers/publishers can restrict devices by their screen size (ie. the diagonal length of the screen). This is specified not via resolution, but by physical size. Eg. the developer can decide that the app should be used only on devices of 10" or larger. Obviously if you try to install a 10" tablet app on your brand new Google Nexus 7 (with a 7" display), you'll run into problems.

Furthermore the developer can restrict devices by the screen's pixel density. The relevant build.prop entry is ro.sf.lcd_density and it's unit is dpi (dots per inch). The screen size is calculated from the screen's resolution and this dpi value. The resolution of a device is fixed, so to emulate a larger screen size and match the app's requirements, you've to calculate and change the dpi. There're a few standard dpi values: 120, 160, 240 and 320. It's probably a good idea to stick with these.

Let's take a look at an example. You've got a phone (or tablet) with an 1280x720 resolution. You'd like to install an app that requires a 10" screen. It's simple math from here. Use the Pythagorean theorem: (1280 / x) ^ 2 + (720 / x) ^ 2 = 10 ^ 2
And the DPI (the value of x) from this is: x = sqr(21568) = 146.86
If you want to stick with a standard DPI value, then the closest one that matches the 10" screen size and the 1280x720 resolution will be 120. This is the value that you'll have to specify in the ro.sf.lcd_density property.

That's all there's to the Play Store compatibility myth.

And now some device parameters to make your life easier ...
(note: all of the following property values come from various forums/blogs and I've no idea whether they're real or not ... so use at your own risk)

• Nexus 7:
  
  • ro.product.model=Nexus 7
  • ro.product.brand=Google
  • ro.product.name=nakasi
  • ro.product.device=grouper
  • ro.product.board=crane
  • ro.product.manufacturer=Asus
• ASUS Transformer Pad (TF300T):
  
  • ro.build.product=EeePad
  • ro.product.model=EPAD
  • ro.product.brand=asus
  • ro.product.name=US_epad
  • ro.product.device=tf300t
  • ro.product.board=EeePad
  • ro.product.manufacturer=asus
• Samsung Galaxy Tab 10.1:
  
  • ro.product.model=GT-P7500
  • ro.product.brand=samsung
  • ro.product.name=GT-P7500
  • ro.product.device=GT-P7500
  • ro.product.board=GT-P7500
  • ro.product.manufacturer=samsung
  • ro.build.product=GT-P7500
  • ro.build.description=GT-P7500-user 3.2 HTJ85B XWKK4 release-keys
  • ro.build.fingerprint=samsung/GT-P7500/GT-P7500:3.2/HTJ85B/XWKK4:user/release-keys
  • ro.build.characteristics=tablet
• Samsung Galaxy Nexus:
  
  • ro.product.model=Galaxy Nexus
  • ro.product.brand=google
  • ro.product.name=yakju
  • ro.product.device=maguro
  • ro.product.board=tuna
  • ro.product.manufacturer=samsung
  • ro.build.product=maguro
  • ro.build.description=yakju-user 4.1.1 JRO03C 398337 release-keys
  • ro.build.fingerprint=google/yakju/maguro:4.1.1/JRO03C/398337:user/release-keys
  • ro.build.characteristics=nosdcard
• Asus Transformer Prime (TF201):
  
  • ro.product.model=Transformer Prime TF201
  • ro.product.brand=asus
  • ro.product.name=US_epad
  • ro.product.device=tf201
  • ro.product.board=cardhu
  • ro.product.manufacturer=asus
  • ro.build.product=tf201
  • ro.build.description=US_epad-user 4.0.3 IML74K US_epad-9.4.2.21-20120323 release-keys
  • ro.build.fingerprint=asus/US_epad/EeePad:4.0.3/IML74K/US_epad-9.4.2.21-20120323:user/release-keys
  • ro.build.characteristics=tablet

P.S.: one "limitation" you'll not be able to (easily ) overcome is app availability by country. Unfortunately the Play Store displays the same "incompatible" message in case you're in an unsupported country. To check whether this is the case, click on "Install", open the device dropdown list and hover the cursor over your "incompatible" device. A tooltip will appear telling you the reason for not being able to install. Of course using a public proxy from a supported country helps a lot in these issues ...