Thursday, December 01, 2011

FIXED! Mac and Excel 2011 -- Can't open XSLX, PPTX, or DOCX files

Have spent HOURS trying to figure out why I get the above error, "Excel cannot open this file.  The file format or file extension is not valid."  every time I try to view an XLSX/PPTX/DOCX file in an email attachment.

I've completely uninstalled Outlook 2011, done system traces to see what I could find, view all sorts of logs, re-installed multiple times, etc.  Even upgraded to Lion.

Turns out, it was the NAME of my hard drive causing the issue.  Go figure.

To check this, go into Disk Utility and see what the name of your HD is.  If it doesn't have ABC123 characters, change the name.  In the example below, it just shows ":" as the name:

To change the name of the drive, just RIGHT CLICK and select SHOW IN FINDER, then rename it as you would any normal file.

Wednesday, March 09, 2011

Android Background Processing

Background processing on mobile devices can be tough -- services, threads, etc, can be killed on a whim when memory/CPU resources start getting low, the device goes to sleep, network connectivity is less reliable, etc.

There are multiple ways to handle background processing in Android. Here's a QUICK overview of each (mainly so I can get it clear in my mind.)

Standard Java threading. Just create a new thread and start it. The issue here is that it is difficult to communicate things back to the UI. You end up having to use "handlers" to pass messages to the UI.

import android.os.Handler;
private void testThread() {
final int PRE_EXECUTE = 1;
final int PROGRESS_UPDATE = 2;
final int POST_EXECUTE = 3;
final Handler handler = new Handler() {
public void handleMessage(Message msg) {
if (msg.what == PRE_EXECUTE)
Log.d("JAVA THREAD", "PRE EXECUTE: " + msg.arg1);

else if (msg.what == PROGRESS_UPDATE)
Log.d("JAVA THREAD", "PROGRESS: " + msg.arg1);

else if (msg.what == POST_EXECUTE)
Log.d("JAVA THREAD", "POST EXECUTE: " + msg.arg1);

new Thread() {
public void run() {
// send a PRE-EXECUTE message just for example
Message msg = Message.obtain();
msg.what = PRE_EXECUTE;
msg.arg1 = 9999;

for (int i = 0; i < 10; i++) {
msg = Message.obtain();
msg.arg1 = i;
Log.d("JAVA THREAD", "ITERATION: " + i);

// send message to UI with result so it can update widgets, etc
msg = Message.obtain();
msg.what = POST_EXECUTE;
msg.arg1 = 12345;


Android utility class to do background processing. Can override methods such as onPreExecute(), doInBackground(), onProgressUpdate(), and onPostExecute() to easily handle background processing and communicating things back to the UI thread for screen updates, etc. This is VERY handy and does all the home-grown handler stuff you'd have to do if you just used Java threads. Almost all of the methods you override run on the UI thread EXCEPT for doInBackground(). Android handles everything for you. The issue with this approach is that the task is tied to whatever started it -- if Android kills the process that started it, then the thread will die, too.

import android.os.AsyncTask;
private void testAsyncTask() {
// Create an AsyncTask that counts to 10 seconds and publishes updates
new AsyncTask() {
protected void onPreExecute() {

protected Integer doInBackground(Void... params) {
for (int i = 0; i < 10; i++) {
return 12345;

protected void onProgressUpdate(Integer[] values) {
Log.d("TASK", "PROGRESS: " + values[0]);

protected void onPostExecute(Integer result) {
Log.d("TASK", "POST EXECUTE ON UI THREAD: " + result);

The recommended way to do anything that is long-running (more than a few seconds, perhaps, such as a background refresh with a web server), is to use a Service. A Service should be well-behaved -- it should not consume battery or memory resources, should not keep the device awake, etc. Services can still be killed be the OS, but the chances are less than other elements as Android gives a higher priority to services. There are still considerations you need to consider -- what if multiple requests to start a service are received? What if the device goes to sleep?

There are two variations of a Service in Android that I know about -- Service and IntentService. Service is mostly used for parallel processing as well as a permanent background process. I've always used the Service class incorrectly and ended up doing a lot of synchronization logic to ensure only a single thread was executing at one time.

And then I found the IntentService. The IntentService ensures that only a single thread is executing at a time. It also ensures that the service is stopped when work has completed (need to verify this!)

CommonsWare ( has released a really nice implementation of WakefulIntentService which makes it a snap to do work while retaining a WakeLock on the device so the CPU is available. Get it here: (Thanks, Mark -- I make it a point to read all of your posts as I'm bound to learn something new!)

Of course, the biggest building block/foundation of Android is the use of Intents and BroadcastReceivers. The thing to consider when processing an intent in onReceive(), is that the CPU might not be available upon exiting from the onReceive() method. Therefore, if you are staring a background Thread or AsyncTask, you may be hosed! You will need to acquire a wake lock yourself, or, better yet, start a background service that does the processing and then shuts down. Check out the WakefulIntentService as it makes things really easy:

import com.commonsware.cwac.wakeful.WakefulIntentService;

public class MyTestService extends WakefulIntentService {

public MyTestService(String name) {

protected void doWakefulWork(Intent intent) {
try {
// do something
} catch (Exception e) {
Log.e(C.TAG, "Evil.", e);

and, to start the service from anywhere in your code:

WakefulIntentService.sendWakefulWork(context, MyTestService.class);