Android 4.1 changed standard behavior for setTextSize.
It used to be that you could use setTextSize(0) and the size would default to whatever was appropriate for the device. Very handy! Unfortunately, it now literally sets the font size to 0. Effectively rendering your TextView invisible. Bad Google! Changes like this make it harder and harder to write code that works on the majority of devices.
I guess that’s why we make the “big bucks”, right? /sarcasm 😉
I recently had an exception report from an eeePC using a mouse which caused the following code to give a NullPointerException:
public void onCreateContextMenu(ContextMenu aMenu, View aView, ContextMenuInfo aMenuInfo) {
AdapterView.AdapterContextMenuInfo theMenuInfo = null;
try {
theMenuInfo = (AdapterView.AdapterContextMenuInfo) aMenuInfo;
} catch (ClassCastException e) {
return;
}
File theFile = myActivity.getListItem(theMenuInfo.position);
//...snip rest of code...
}{/java]
The only way that theMenuInfo would be NULL in order to cause the NullPointerException is that the passed in aMenuInfo was NULL -- and that is not supposed to be the case.
I am not quite sure how such an event occurred. It could be a result of "right-clicking" on a spot where there is no list item shown, except that the behavior in that case should have not resulted in a context menu since there is no item there at all. While I should not have to protect my code against a NULL being passed in for the required ContextMenuInfo parameter, I have to live in the world that <em>is</em>, not the world of <em>should</em>. Who knows, maybe this is the start of a trend where "right clicking" on the "white space" of a list will pass in NULL for that parameter and cause a completely different menu to popup for quick actions that provide the same functionality as clicking on the Menu button and choosing some deeper submenu from that list. Then again, it is probably just a bug in the OS and will be fixed at a later point in time. Either way, it's best to protect against NULL parameters even if they should never be NULL.
My new code:
[java]public void onCreateContextMenu(ContextMenu aMenu, View aView, ContextMenuInfo aMenuInfo) {
AdapterView.AdapterContextMenuInfo theMenuInfo = null;
File theFile = null;
try {
theMenuInfo = (AdapterView.AdapterContextMenuInfo) aMenuInfo;
theFile = myActivity.getListItem(theMenuInfo.position);
} catch (ClassCastException cce) {
return;
} catch (NullPointerException npe) {
return;
}
//...snip rest of code...
}
If you know why the ContextMenuInfo parameter is sometimes NULL, please feel free to share the reason as I know several developers that would be interested in it besides myself.
What class memory card to get for the Nexus One
I was on the Google help forums this morning and I read a post by a guy who said he was getting a 16 gig class 6 memory card for his Nexus One so I figured I would come on here and explain why this individual is spending more money than necessary.
There are two things you need to consider when buying a memory card..
I think most people understand size numbers. The bigger the number, the more music, pics, video, etc you can store on the card.
Speed on the other hand is a bit of a mystery to some. Continue reading
The Android notification bar has been white for a very long time. A great many apps that put up icons inside this bar create black icons with transparencies so they appear black on white when viewed against this white notification bar. Unfortunately, with Android 2.3.3+ and 3.0+, the notification bar is now black. Black icons on black bars do not show up well at all.
I highly advise against creating separate icons for the different versions and instead offer the tip of creating a white background for your black icons. In my apps that require a notification icon, I gave the icons a round, white background that used the alpha channel to fade the white from the center to the edge. The effect is that on the older, white notification bars, no difference is detected since white fading into white is the same thing as nothing at all. On a black background, however, the effect is that my black icon is visible within a white circle that fades to black, making it look like a modern, 3D rounded icon.
Personally, I detest the current state of my 2.3.4 phone’s notification colors since most of the apps currently use black or dark grey notification icons (including stock apps) and as such makes it nearly impossible to see them at a glance when checking my phone for messages out in bright daylight. Whomever’s bright idea it was to push this change out to phones that have been using and expecting white notification bars for years now should be given a painful wedgie!
Pro Tip: when you loop through the results of a query like this:
$theDatabase->getSqlData($theSQLtext);
while ( $theDatabase->getNextRow() ) {
//... do a ton of stuff ...
}
I would like to point out that it will fail eventually. Why? Oh there’s nothing wrong with it, per se…
But if somewhere in all of that ton of stuff inside the while loop you ask the database for something else (like a small list of items for a drop down control), then when you get back to the “while” line, it will now either return the wrong data row or most likely just end prematurely — because of lazy coding!
All that is needed to avoid this hard to detect bug, is to save off the query result given in the first line and use it in the “while” line. No question now which row will be returned and everything will be correct no matter how many nested database calls you put inside the while loop.
$theQueryResult = $theDatabase->getSqlData($theSQLtext);
while ( $theDatabase->getNextRow($theQueryResult) ) {
//... do a ton of stuff...
}
ListViews and GridViews are great widgets to use in an Activity for your app. Sometimes it is useful to also create smaller versions of them for dialogs within your app. There’s only one problem: Context Menus. If you have tried to put a context menu on a ListView inside a dialog, you may have found out that while onCreateContextMenu() is called, onContextItemSelected() is not. There is a workaround, though, because onContextItemSelected() is actually a convenience method called from onMenuItemSelected(int, MenuItem). If you add the following method to your dialog containing the ListView (or GridView), you will find that onContextItemSelected() is working again.
@Override
public boolean onMenuItemSelected(int aFeatureId, MenuItem aMenuItem) {
if (aFeatureId==Window.FEATURE_CONTEXT_MENU)
return onContextItemSelected(aMenuItem);
else
return super.onMenuItemSelected(aFeatureId, aMenuItem);
}
Some Motorola Cliq phones are having issues trying to pick a contact photo using something other than the Gallery app that comes with the phone. Motorola is aware of the issue, but I am trying out a workaround for it in my File Browser app. Basically, the problem is that an OutOfMemoryError could result from attempting to pick a large photo because the Intent being used does not specify the size to be returned. Normally, I would just use getIntExtra(“outputX”,defX) and getIntExtra(“outputY”,defY) in order to get what the caller wanted as a size, but since Motorola’s contact app does not provide those Intent Extras, it would return the full sized photo.
Instead of waiting for Motorola to modify their app, I decided to check the name of the caller and provide a default size for that particular app.
if (myActivity.getCallingPackage().equals("com.motorola.blur.contacts")) {
outputX = outputY = 48;
}
Android drawable resources include the ability to provide and XML resource that specifies a different name for it’s bitmap resource. It is an especially handy mechanism for library code to refer to a specific drawable resource that your app provides under a different name.
For example a drawable xml named “app_icon.xml” could contain:
<!--?xml version="1.0" encoding="utf-8"?--> <bitmap xmlns:android="http://schemas.android.com/apk/res/android" android:src="@drawable/ic_MyAppName" />
If you used this kind of resource as your application’s icon resource inside your AndroidManifest.xml file, though, you have a problem. While technically, the app will function normally, the Android Market tries to check to make sure your app’s icon meets some guideline criteria and cannot handle an XML drawable. Android Market will refuse to upload your app and tell you “The icon for your application is not valid. Please use a 48×48 PNG.”
If you use XML drawables, please keep this limitation in mind and do not reference them inside your AndroidManifest.xml.
I have been busy updating the next version of my File Browser app to work with Android 3.0 and display correctly on tablet devices. Almost everything worked as it had in prior versions of Android, however, not everything worked as intended. Continue reading
The Android 2.3 SDK in Eclipse enforces the optional Argument Index if you use multiple arguments inside a string resource.
Still OK:
Flagged as an error:
Google is taking issue with implicit argument ordering on the grounds that it is not Best Practice to leave it up to the translators to place the argument specifiers if they need to shift around the order due to language grammar. While I feel that taking away Continue reading