Voice Command on Google Play: Open apps with your voice! Access any of your applications in seconds. Customize the names of your applications making them easier to speak. Replace endless pages of apps with a single icon, Voice Command.

Voice Command is available for free on the Google Play Store and does not include any advertisements.

Cube Complex on Google Play: Experience an always changing multi-colored background of shifting cubes that glow with light. The camera and background transition to maintain a clean and unique appearance.

Click here to view the video on YouTube.

Android Download: Texts From Last Night APK

Froyo Lives tshirt design

A good friend of ours, Erin from Erin Creative Design, entered in the Woot shirt design derby and to show our support we present you with this shameless plug.

If you have previously purchased a shirt from Woot and you like the design please show your support by voting it up.

Android Bacteria Live Wallpaper

Its been a long few days to make everything work however I finally got everything transitions from canvas to OpenGL. Canvas was ideal as it was the easiest to quick develop for however for wallpapers the canvas implementation is seriously flawed. The issue is that cpu throttling directly affects canvas rendering as its not hardware accelerated before 3.0. Without the hardware acceleration the canvas drawing gets gets super choppy and reduced to 1-2 frames per second which is completely useless.

Also it may be good to note the OpenGL implementation is entirely thanks to AndEngine and a few awesome plugins that can be found on their forum. Without it, converting my code to OpenGL from canvas would have take much longer to complete.

So what can we do to make our lives, the developer, a little easier while at the same time getting the user better content? The answer to all your problems is the WebView. WebViews can be created in the activity with only a few lines and are quite powerful. They can process Javascript, CSS and of course basic HTML although a lesser known feature may be the fact that from your activity you can actually communicate bidirectionally with your in page Javascript however thats a discussion for another day.

First lets take a look at how we can break up a large help file into a few pages.

Here we can see a ListView of help topics on the left and a help page on the right which is actually a WebView. Now I’m not going to discuss how to build a custom ListView as that is outside the scope of this tutorial instead we are just going to focus on how do you go from a ListView to a WebView fluidly. Personally I broke this into two separate Activities as I like to keep my segments of code as small as possible and multiple files just makes me feel clean.

ListView Activity

clickListener = new OnItemClickListener() {
	@Override
	public void onItemClick(AdapterView adapter, View view, int position, long id) {
		Intent myIntent = new Intent(getApplicationContext(), ActHelpWebView.class);
		myIntent.putExtra("filename", helpDisplay.get(position)[2]);
		startActivity(myIntent);
	}
};

Here we can see the listener I used for my ListView which simply launches our Activity that contains the WebView. It is also key to note that here I am passing along the data of which file to open with the Intent. This is done in my case by using a List where the array looks like this {“icon to use”, “title”, “htmlpage”}. With this knowledge it makes sense why I am passing helpDisplay.get(position)[2] as that is the help file that the user has requested to be loaded.

Now that we have passed the Intent we need to have a few things setup before we move forward. First you need to have your ‘mini’ site ready to go. For me I just created a simple style sheet in CSS and then made a single page layout that I filled in with all my content and images. You can store all of these files in the assets directory of your application as seen below. Just a reminder, your assets folder goes into your root application directory and not into the ‘res’ directory.

Now that we have the Intent and our assets ready to go lets finally make our WebView and hopefully educate our users a little better than before. To do this we need to first receive our intent, create our WebView and finally pass the file location to the WebView for processing.

public class ActHelpWebView extends Activity {
	
	private Context context;
	private WebView webView;
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		this.context = this;
		setupWebView();
		displayHelpPage(getIntent().getStringExtra("filename"));
	}
	
	/**
	 * Private method to launch the webview for the requested filename
	 * @param filename
	 */
	private void displayHelpPage(String filename) {
        webView.loadUrl("file:///android_asset/help/" + filename);
        setContentView(webView);
	}
	
	/**
	 * Private method to initialize our webview
	 */
	private void setupWebView() {
        webView = new WebView(context);
        webView.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
        webView.setBackgroundColor(color.black);
	}

}

This should launch your WebView with all the default parameters. In certain cases you may want to enable additional features such as zooming, Javascript or Activity to Javascript communication as mentioned earlier. There are a variety of ways you can further this however I believe a few Stack Overflow searches can aid you past this point.

Android Market

Today we have some unfortunate news to report on. Google has changed the Android Market in several ways and unfortunately one of these changes has crippled searches. All searches of the Android Market now require a valid device id which is unfortunately quite difficult to retrieve on certain devices. However on essentially all devices you must have root to even attempt the process.

As you may know, App Stats already includes a method of retrieving this ID for users with root on their device however this will not work for all phones. Currently we are trying to come up with work around methods to resolve this issue for everyone unfortunately it will take some time to compensate for this critical change made on Google’s end of things.

First, sending an email is actually pretty easy and I am sure from a simple Google search most developers could have an email sent in a few minutes of after copying and pasting. The trick comes from when you need to add attachments and this is what is confusing. Without making it obvious, the stock Google applications can not handle multiple attachments and the only email application, that I know of, which can handle an intent with multiple attachments is K9 email. That said, you definitely do not want to rely on the user having a specific email application.

So how do we get around this? Zip files. I hate having to use zip files when it comes to something as simple as sending a few pictures however its the only thing I could find that actually worked as intended. Using the code below you can create a class to handle file zipping. Its important to note that to send the attachment, the intents seem to need to have global access to the files. To do this you can temporarily store the zip file on your SD card by using Environment.

This code is thanks to an article written by Jon Simon located here Zipping Files with Android

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class Zip {
	private static final int BUFFER = 2048;

	private String[] _files;
	private String _zipFile;

	/**
	 * This class allows for the automated creation of Zip files when given a String array of file paths. 
	 * 
	 * @param files - String array containing the path of all the files to be zipped
	 * @param zipFile - The destination of the Zip file.
	 */
	public Zip(String[] files, String zipFile) {
		_files = files;
		_zipFile = zipFile;
		doZip();
	}
	 
	/**
	 * Private method to handle building a Zip file
	 */
	private void doZip() {
		try {
			BufferedInputStream origin = null;
			FileOutputStream dest = new FileOutputStream(_zipFile);

			ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(
					dest));

			byte data[] = new byte[BUFFER];

			for (int i = 0; i < _files.length; i++) {
				System.out.println("Adding: " + _files[i]);
				FileInputStream fi = new FileInputStream(_files[i]);
				origin = new BufferedInputStream(fi, BUFFER);
				ZipEntry entry = new ZipEntry(_files[i].substring(_files[i].lastIndexOf("/") + 1));
				out.putNextEntry(entry);
				int count;
				while ((count = origin.read(data, 0, BUFFER)) != -1) {
					out.write(data, 0, count);
				}
				origin.close();
			}

			out.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}

Okay so now that we zipped our images (or whatever you needed to zip) here is how you actually create and send an email.

//first zip the files
new Zip(fileStringArray, zipDestinationString);
Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_EMAIL, new String[]{"someaddress@somesite.com"});
intent.putExtra(Intent.EXTRA_SUBJECT, "Email Subject");
intent.putExtra(Intent.EXTRA_TEXT, "Email Message");
intent.setType("application/zip");
intent.putExtra(Intent.EXTRA_STREAM, Uri.parse("file://" + zipDestinationString));
startActivity(Intent.createChooser(intent, "Send Email"));

And presto, when you run that code you a chooser should pop up asking the user how they want to handle the request. For me I get the option of Bluetooth or using Gmail. As always if you feel I left something out or have questions just leave a comment.

Rich Text Editor

I was recently working on a project and I needed a rich text editor for a piece of the project. All of the editors I could find functioned well however the HTML they would write was just plain wrong. Every single one I tried, other than Xinha, would place lines of text in div tags and empty lines would be a break tag wrapped in divs. If you are SEO savvy you know that just randomly wrapping a ton of text in div tags all over your site certainly wont be helping you any and paragraphs are the way to go.

That in mind I finally found Xinha and creating paragraphs properly wasn’t the only thing it did well. Its over the top customizable! Best of all its easy to understand how to customize it and if you need to run multiple customizations its very easy to support that as well. Furthermore compliance was a top priority for the Xinha team so you will find it works well across a lot browser versions. So if you need a text editor for a project, look no further.

Xinha Rich Text Editor