I think I have fully made up my mind that my next Android phone will be a Google Nexus device. The Nexus devices offer something that no other Android phones on the market offer: a clean, stock, the way Google wanted it to be device that receives timely updates as soon as they are available. You don’t have to worry about terrible pre-loaded skins that completely bog down even the fastest devices on the market, as well as the lack of uninstallable bloatware that has unfortunately reared its ugly head onto these very expensive devices.
Manufacturer Android Skins
Android device manufactures, such as Motorola, HTC, Samsung, and LG (henceforth known as “the OEM’s”) all modify the version of Android that come pre-installed with their phones. They all put their own UI on top of Android to “enhance the experience of Android”, “add more features”, and lastly (but most importantly), “differentiate themselves from the competition”. The OEM’s all have their own unique skins, such as MotorBlur, Sense, and TouchWiz.
On the surface, these look like simple, flashy skins. However, they have become much more than that. Originally, that’s all they were, skins/launchers. If you wanted to “remove” MotorBlur, or Sense, etc., you would just install a different launcher app (such as Launcher Pro). However, they have since evolved to be more than just a skin. They now deeply embed hidden background processes into Android that consume RAM, CPU, and worse yet – battery life. Thus, simply installing Launcher Pro will not fix the problem.
But how can they differentiate themselves if they are all running the same OS?
Simple…by making great hardware. When someone buys a phone, one of the first things they look at is the hardware. They look at the size of the screen, the thickness, the build quality, the presence (or lack of presence) of a physical qwerty keyboard, the weight, the color, the carrier the phone is on, the battery life, the call quality, the screen quality, internal storage, SD card availability, camera quality, presence of front-facing camera, etc. Those are all *incredibly* important factors of a device. 100% of those are areas that the OEM’s have the complete expertise on innovating and differentiating themselves on. You can pretty much look at any Android phone and immediately tell who makes it by just looking at the way it’s built. *THIS* is where they should be differentiating themselves on.
The OEM’s are not software experts. If they were, they wouldn’t be using Android. They would instead have made their own OS from scratch. Google made a great mobile OS; one that can compete with the iPhone. That is why they are using it. In my very honest opinion, the OEM’s lost their ability to differentiate themselves in the software space by adopting an external OS. How many people do you know say “I can’t wait to get that MotorBlur phone!”? The answer is 0. People want an Android phone. They want to own a device that is part of the Android ecosystem, not a device that tries to invent its own platform.
The quicker the OEM’s realize that, the better off they will be.
Recently, an increasing number of media companies have been blocking access to Flash 10.1 content on non-PC devices (i.e. Android Phones, Google TV, PS3, etc.). The reasoning for this makes no sense as I can plug my laptop into my TV and watch sites like Hulu, Fox.com, and NBC.com content without any problems. However, doing so on a game console, Google TV device, or even an Android Phone is somehow different in their view. It shouldn’t be a DRM issue either, as that should be handled by the Flash player itself.
Oh well. In the past, this could be worked around by simply altering the user-agent string on the browser. In this case, the browser would basically lie to the server and trick it into thinking that it’s running on a PC web browser. As a result, the content would play just fine.
However, that no longer works. Instead of simply relying on the user agent string of the browser, they are now also looking at the version of Flash Player running on the device. A string of the version of Flash you are running is sent to the server to check if you are using a “supported device.” You can find out what your Flash version string is by visiting this page: http://kb2.adobe.com/cps/155/tn_15507.html. Visiting that page should show you something similar to this:
To verify that this string is actually being sent to the server, I opened up Wireshark and sniffed some traffic on Hulu. While watching an episode of Hells Kitchen on Hulu, I sniffed for
HTTP GET requests. Below is a screenshot of the TCP Stream for the
As you can see from the screenshot above, there are a lot of variables appended to the
GET request. The most interesting one is the:
flashPlayer=WIN%2010%2C1%2C103%2C19. This tells the server which version of Flash Player the system is running. If you remove the delimiting characters from the
GET request, you would see that the version string matches that of the string in the first screenshot above. If you were running Android, the version string would contain
AND instead of
That is not the only
GET request of interest. Indeed, there are others which contain appended variables declaring the OS, and the browser being used. All of this information together can identify the device accessing the service. However, remember that because all of this code is coming from the client, it can be altered.
So, in theory, if we were to replace the Flash Player version (as well as any other string sent to the server that could reveal the identity of the device accessing the service) with known values that work (such as one from an ordinary PC), that device should be able to access the service, since the server thinks the device is just a regular, “supported” PC.
Unfortunately, modification of the packet on-the-fly is the problem. I cannot find any suitable software that is capable of making these changes on-the-fly to the HTTP packets. A proxy application would be best suitable for this purpose, as it can change the user-agent-string and potentially other variables within the packet before being sent out to the server. Unfortunately, I cannot locate any software that would easily give me the granular control needed to make this work.
After looking into Squid, and Privoxy, the best application that I have tested so far is TcpCatcher (http://www.tcpcatcher.org/). This is a great app that basically combines Wireshark with a proxy server for HTTP connections. It can even perform find-and-replace functionality within the packet. Unfortunately, as powerful as the application is, it does not have the ability to find-and-replace more than one variable at one time. For example, to make this work, I would need to change the user-agent string, as well as find-and-replace any instances of
flash=, and even
os= with known values that work. However, this application can only allow one or the other to be changed. If I change the user-agent string, I cannot perform a find-and-replace on the packet. Thus, it will not work to fix the problem, as we need to completely mask the identity of the accessing device and trick the server into thinking that it’s just an ordinary PC.
If anyone is able to locate software that can make this work, please post it in the comments.
For Java apps to run in Windows, a JRE (Java Runtime Environment) must be installed. If it’s installed, but your Java apps are throwing errors that it cannot find the JRE, then you will need to add an environment variable to point to the Java bin directory.
Here is a screenshot of such an error I received when trying to run the Android SDK:
(Also notice the typo in the above message: “Checking it it’s installed in …”)
Below are instructions for fixing this error on Windows 7 x64 with the 64-bit JRE installed:
- Click the “Start Orb”, and type:
- In the search results, you should see “System” appear. Click on it, and you should have the “View basic information about your computer window” appear.
- In that window, on the left hand side, you should see a link to “Advanced system settings”. Click it. (Accept all UAC prompts)
- The “System Properties” window will appear. Click the “Advanced” tab.
- On the “Advanced” tab, click the button towards the bottom of the window titled “Environment Variables…”
- The “Environment Variables” window should appear. In this window, on the bottom half, you should see a section titled: “System variables”. Scroll down that list for an entry titled:
Path. Click the “Edit” button.
- The “Edit System Variable” window should appear. In this window, select the textbox for “Variable value:”. Scroll to the end of the entry, and add a semicolon (;) to the end of the line (assuming no semicolon is currently there).
- You will then need to locate where your Java bin directory is located. For me, on 64-bit Windows 7 with the 64-bit JRE installed, it is located in the following path:
C:\Program Files\Java\jre6\bin(This is the default location if installing the 64-bit JRE)
- Copy and paste the path to the bin directory after the semicolon we just added to the “Variable value:” textbox.
- Click OK to all the windows, and your application should work.
I love my Motorola Droid (and Google Android), but I kept having a small issue: All my Google Searches were saved. That is, every time I went to perform a Google Search, the Google suggestions would show my previous search queries. I personally dislike this behavior, since it consumes screen real estate from the search suggestions. (I even disable the “remember form data” feature on my PC’s browser.)
Here is a picture of the problem:
If you click on the “Clear History” link, you get this pop-up:
The pop-up states: “Go to Preferences for more options.” For the longest time, I kept thinking it was a browser setting (even though the “Remember form data” option is disabled). But then it occurred to me: It’s a not a browser setting, it’s a website setting. Indeed, Google’s mobile search site has an option for saving mobile search history.
How to fix it?
Perform a Google search, and navigate to the bottom of the page. Click the “Preferences” link:
On the Preferences page, select the “Do not save searches” button, and then click “Save”:
And that’s all there is to it!