Husky or Grainy

After tastes/flavors: like cereal or raw grains.

A grainy taste indicates that you’ve over milled your grains. This also may be because the grain is overly toasted. You will find this off-flavor in “All-grain” batches. To avoid, try to let your grain age for a week or two after milling. This will allow for the harsh aromas and flavor to dissipate.

Medicinal

After tastes/flavors: cough syrup, Band-aids, smoky, clovers (spices).

Phenols are usually to blame for this off-taste. These phenols react to chlorine-based sanitizers, so it’s best to boil your equipment with hot water, or use BrewVent Sanitizer because it’s oxygen based not chlorine based, so there’s no need to rinse off.

Metallic

After tastes/flavors: metal, iron, sometimes described like pennies or blood.

If the wort is processed in unprocessed metals (cast iron, sometimes aluminum and steel) will cause this flavoring. Kegs or bottle caps can also be a source for this flavor. So, use stainless steel where you can for the majority of all your brewing equipment.

Moldy

After tastes/flavors: mold, mildew, musty.

Mold can definitely grow in beer, so make sure all your equipment is clean and sanitized. If your fermenting in a damp, danky area rather than a cool dry area, mold can grow in your brew while in the fermenter. Try to keep this area dry and cool. If you see that you have moldy grain, discard it.

Oxidation

After tastes/flavors: stale or old tasting, wet cardboard, increased bitterness.

Oxidation occurs when oxygen negatively affects your beer, i.e. too much oxygen in the concoction. If you leave too much air in the bottle when bottling, this will sometimes lead to oxidation flavors. You can prevent this from happening if you reduce your “splashing” from one container to another. “Splashing” introduces more air to your brew, which isn’t good for a final product.

Soapy

After tastes/flavors: soap, bitter, slippery.

Soap residue not properly washed off equipment or partaking glasses. Also, if you leave the beer in the fermenter for too long, then the fermentation process with break down fatty acids to create a soapy flavor in your beer. Properly wash all equipment and boil them if needed. Partaking glasses should be washed thoroughly with hot water.

Skunky

After tastes/flavors: like a skunk, rubbery, cat musk.

When your hops are exposed to sun light or UV lights. The acids in the hops will breakdown yielding hydrogen sulfide that reacts to the yeast. The reaction is called Mercaptain and is the same chemical skunks produce when they spray their targets. To void this flavor, ferment away from direct sunlight. Bottle your beer in dark, brown bottles. And, store your brew in a dark, cool area.

There are a few other flavors left on the list that I will cover shortly in the next post. Stay tuned!

Also, check out these great sources: morebeer.com and howtobrew.com. They both have great information if you’re starting to make your own damn beer. Also, check out austinhomebrew.com for beer kits, recipes, instruction, and anything homebrew.

I read some useful articles about off-flavors and after tastes that may affect the final flavor of your beer. Certain brewing procedures may change the quality and taste characteristics (like dryness, bite, spice…etc). If something doesn’t taste right, then here are a few indicators and what may have caused them during the your brewing process…

Acetaldehyde

After tastes/flavors: a hint of green apples or a freshly cut pumpkin.

Acetaldehyde is a naturally forming compound produced by yeast in the fermentation process. This generally means that the beer is too “young” and may need more time to condition. So be patient, the beer isn’t quite ready to enjoy.

Alcoholic

After tastes/flavors: overpowering, hot, spicy, or sharp alcohol flavor.

Fusel alcohols are produced at higher temperatures during the fermentation process, so if you pitch your yeast when the wort is higher than 80 degrees Fahrenheit, higher weight fusel alcohols are produced (harsh and bitter tasting). You may also want to remove access sediment in your wort when starting primary fermentation.

Astringent

After tastes/flavors: tart, puckering, dry, vinegary, and sometimes powdery.

This can be caused by steeping your grain in water that’s too hot, or if you’ve steeped for too long. You want to make sure that your mash’s pH level is in between 5.2 – 5.6. Also, leave the hops that cling to your fermentor out of your beer because of it’s bitter qualities.

Cidery

After tastes/flavors: apple cider, acetaldehyde, or wine.

This is usually caused by using too much corn or sugar cane rather than liquid or dried malt extracts. If you need more sugar for the carbonation process, you may want to try organic honey or syrups.

Diacetyl

After tastes/flavors: buttery, butterscotch, smell of buttered popcorn.

Good for ales, bad for lagers. This situation is difficult since yeast naturally produces this compound during fermentation. A great indicator of whether or not your yeast is acting they way it should (bubbling and producing alcohol) is if it takes it a while to reach this state. The longer the wait, the more diacetyl in your beer.

Estery (Fruity)

After tastes/flavors: banana flavored, and not so prevalent: strawberry, grapefruit, or pear.

Again, this is naturally produced by yeast during fermentation, but yeast will produce more esters if fermented at a higher temperature. If you taste banana, you may want to try to lower your temperature during fermentation.

Grassy

After tastes/flavors: smells like freshly cut grassy, or moldy.

If you tastes these flavors, then your grain has grown mold or bacteria. You need to store your grain in a cool, dry place. If your grain is pre-milled, then make sure to use it within 2-4 weeks prior to milling.

Next time, I will continue this series with other common off-flavors. And, by then I will be able to determine what after tastes are in my brew.

Check out these great sources: morebeer.com and howtobrew.com. They both have great information if you’re starting to make your own damn beer. Also, check out austinhomebrew.com for beer kits, recipes, instruction, and anything homebrew.

There was one limitation along the way that I decided to take matters into my own hands. I needed to hide the “Tap to refresh…” header when there’s the same amount of visible items and total number of items in the list. The only area I could see this information available to me was located in the onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) method inherited by OnScrollListener.

I found out that this was a little trickier than it looked. First, this is a hack and by no means the final implementation. As of right now, this was the only thing I could think of that actually does what I expected it to do; hide the ListView header when the list doesn’t fill out its parent’s view.

Below is the first implementation of this workaround…

..

@Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        ..

        if(mRefreshView != null) {
        	((LinearLayout) mRefreshView.findViewById(R.id.hack1)).setVisibility(visibleItemCount == totalItemCount ? View.GONE : View.VISIBLE);
    		((LinearLayout) mRefreshView.findViewById(R.id.hack2)).setVisibility(visibleItemCount == totalItemCount ? View.GONE : View.VISIBLE);
    		
    		((View) mRefreshView.findViewById(R.id.hack3)).setVisibility(visibleItemCount == totalItemCount ? View.GONE : View.VISIBLE);
    		
    		mRefreshView.setVisibility(visibleItemCount == totalItemCount ? View.GONE : View.VISIBLE);
        }

        ..
    }

..

So, mRefreshView is the inflated LinearLayout for the ListView header; it has two orienting children (LinearLayout) and one View. So, for this to work, you MUST declare setVisibility(View.GONE) for each child view. If you don’t, the mechanism for drawing a ListView on your device’s screen renders each child’s layout parameters. Don’t ask me why, because I have no idea…it just does

I hope this shed some light on the subject. Take this with some considerations as it does check to see if the number of visible items are the same number of total items when you scroll your ListView. I’m not seeing any memory leaks or issues right now, but they might manifest themselves if your logic is a bit beefier, so keep it light. If anyone knows why a ListView header renders leftover views that are not set to View.GONE, please leave a comment! Thanks and enjoy!

So, when creating your XML layouts in your project, have you ever asked yourself, “why do I have to type android: every time I declare an attribute?”

Well, the short answer is, YOU DON’T HAVE TO USE ANDROID: EVERYTIME! You can change the xmlns:android namespace declaration to whatever prefix you want. Please, take a look below to see how you can implement this in your next project.

Old Declaration

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"... />
<TextView android:layout_width="fill_parent"... />

New Declaration

<LinearLayout xmlns:a="http://schemas.android.com/apk/res/android"... />
<TextView a:layout_width="fill_parent"... />

If you want the long answer, here’s the magic of Wikipedia. Essentially, you are referencing a variable android to the Android specific namespace, http://schemas.android.com/apk/res/android. You can declare any variable name you want. You’ve now reduced the time it takes to type “android” by more than 85% when declaring a single letter variable for your namespace attributes.

For those of you that want to retrofit this suggestion in your existing projects, here’s a quick couple of steps you can follow to clean up your namespaces.

• Step #1: Open up a layout file.
• Step #2: Change the “xmlns:android” namespace declaration to desired prefix (e.g., xmlns:a).
• Step #3: Change all occurrences of “android:” in your layout file to your new prefix (e.g., a:).
• Step #4: Repeat for all layout files you want to adjust.

And, there you have it fellow dev machines. This will save you time and money in the long run. Happy deving!

The main goal of the ActionBar is to provide vital information to the user about your application. This is also a great place to use your icon or logo for brand recognition and consistent navigations throughout the app. Now the user subliminally thinks about your logo as a specific navigational action. If the user needs to return to the home screen in the app, they have to visualize your brand.

So, how do you implement ActionBarCompat? You will need to make sure that the target SDK level is at least 11 in your AndroidManifest.xml:

<manifest ... >
    <uses-sdk android:minSdkVersion="4"
              android:targetSdkVersion="11" />
    ...
</manifest>

When you declare this in your manifest, the Android SDK and the ActionBarCompat library project will utilize native declarations for devices greater than API 11.

Next, include these files in your project (create a new package including these classes):

• ActionBarActivity.java
• ActionBarHelper.java
• ActionBarHelperBase.java
• ActionBarHelperHoneycomb.java
• ActionBarHelperICS.java
• MainActivity.java
• SimpleMenu.java
• SimpleMenuItem.java

If you take a closer look at MainActivity.java, you can see that this activity extends the ActionBarActivity class. In ActionBarActivity.java, this class extends the Activity class that we all know and love. What’s great about this particular class is that it does all the heavy lifting for us to utilize the title bar as a pseudo-ActionBar.

You will need to makes sure that you are importing the available /res folders. In that folder, you will see layouts covering all API levels (including ICS). You can take a look at the /res/values folder and make necessary adjustments for styling and height dimensions on pre-API 11 devices.

So, that’s the 50,000 foot view of this project. Make sure that you’ve included all these files in you project and make the necessary adjustments tailored for you application. If you have any other questions, or something’s not working correctly, please leave a comment. Also, take a look at this project in much greater detail at Android Developers.

It’s great that AOSP is available to all developers and can be implemented in all your future projects; just make sure you provide credit where credit is due. Please take advantage of what Android Developers provides for us devs. Happy deving!

It’s a simple class that extends Toast. We will modify the constructor to vibrate your device when this new Toast is displayed on screen. Below is the ~5 lined class:

public class VibratingToast extends Toast {
	public VibratingToast(Context context, CharSequence text, int duration) {
		super(context);

		((Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE)).vibrate(300);

		super.makeText(context, text, duration).show();
	}
}

Now all you have to do is call your new Toast when you want some vibrations:

new VibratingToast(getApplicationContext(), "some message that needs vibrations...", Toast.LENGTH_LONG);

And, don’t forget that you will need to declare vibrating permission in your AndroidManifest.xml:

<uses-permission android:name="android.permission.VIBRATE" />

Easy and simple! Happy deving!!!

P.S. – if you want to get fancy and add another parameter to our constructor to accept a vibrating duration integer, please leave a comment or snippet on gist.github.com.

REST clients are a mobile app developers best friend. They allow developers to make lightweight network calls to useful APIs such as the Graph API, Twitter’s API, and Google’s family of APIs including Maps, Google+, and Youtube. I came across a great example, RESTclient for Android by Tyler Smith, and used this implementation to create a foundation for a Blackberry REST client.

Introducing RESTclient for Blackberry with basic authentication and JSON body posting (notice that this implementation only utilizes the REST verbs GET and POST):

public class RestClient {
	private String _url;

	private Vector _headers;
	private Vector _params;

	private String _json;

	private int _response_code;
	private String _response;

	private boolean _authentication = false;
	private String _username;
	private String _password;

	public RestClient() {
		_url = null;

		_headers = new Vector();
		_params = new Vector();
	}

	public RestClient(String url) {
		_url = url;

		_headers = new Vector();
		_params = new Vector();
	}

	public void addBasicAuth(String username, String password) {
		_authentication = true;

		_username = username;
		_password = password;
	}

	public void addHeader(String name, String value) {
		_headers.addElement(new NameValuePair(name, value));
	}

	public void addParam(String name, String value) {
		_params.addElement(new NameValuePair(name, value));
	}

	public void execute(int method) throws Exception {
		switch(method) {
		case RestMethod.GET: {
			HttpsConnection request = (HttpsConnection) Connector.open(_url + addGetParams());
			request.setRequestMethod(HttpConnection.GET);
			addHeaderParams(request);

			executeRequest(request);
			break;
		}
		case RestMethod.POST: {
			HttpsConnection request = (HttpsConnection) Connector.open(_url);
			request.setRequestMethod(HttpConnection.POST);
			addHeaderParams(request);
			addBodyParams(request);

			executeRequest(request);
			break;
		}
		}
	}

	private void addHeaderParams(HttpsConnection request) throws Exception {
		for(int i = 0; i < _headers.size(); i++) {
			request.setRequestProperty(((NameValuePair) _headers.elementAt(i)).getName(), ((NameValuePair) _headers.elementAt(i)).getValue());
		}

		if(_authentication) {
			byte[] cred = Base64OutputStream.encode((_username + ":" + _password).getBytes("UTF-8"), 0, (_username + ":" + _password).length(), false, false);

			request.setRequestProperty("Authorization", "Basic " + new String(cred).toString());
		}
	}

	private void addBodyParams(HttpsConnection request) throws Exception {
		if(_json != null) {
			byte[] data = _json.getBytes("UTF-8");

			request.setRequestProperty("Content-Type", "application/json");
			request.setRequestProperty("Content-Length", String.valueOf(data.length));

			OutputStream os = request.openDataOutputStream();

			os.write(data);
			os.flush();
			os.close();
		}
	}

	private String addGetParams() throws Exception {		
		StringBuffer buff = new StringBuffer();
		if(!_params.isEmpty()) {
			buff.append("?");

			for(int i = 0; i < _params.size(); i++) {
				buff.append(_params.size() > 1 ? "&" : "" + ((NameValuePair) _params.elementAt(i)).getName() + ((NameValuePair) _params.elementAt(i)).getValue());
			}
		}

		return buff.toString();
	}

	public int getResponseCode() {
		return _response_code;
	}

	public String getResponse() {
		return _response;
	}

	public void setURL(String url) {
		_url = url;
	}

	public void setJSONString(String json) {
		_json = json;
	}

	private void executeRequest(HttpsConnection request) {		
		try {
			_response_code = request.getResponseCode();

			if(_response_code == HttpsConnection.HTTP_OK) {
				InputStream is = request.openInputStream();

				int len = (int) request.getLength();
				if(len > 0) {
					int actual = 0;
					int read = 0;
					byte[] data = new byte[len];
					while((read != len) && (actual != -1)) {
						actual = is.read(data, read, len - read);
						read += actual;
					}

					_response = new String(data).toString();
				}

				is.close();

				_params.removeAllElements();
				_headers.removeAllElements();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

Take a look at this snippet of code…

public void execute(int method) throws Exception { .. }

We define int method by invoking the RestMethod class:

public class RestMethod {
	public static final int GET = 0;
	public static final int POST = 1;
}

And there you have it. If you have anything else to contribute, please feel free to comment below. Thanks to Tyler Smith, and the other contributors for this evolving code. Happy deving!

UPDATE:

And the NameValuePair class:

public class NameValuePair {
	private String _name;
	private String _value;

	public NameValuePair(String name, String value) {
		_name = name;
		_value = value;
	}

	public String getName() {
		return _name;
	}

	public String getValue() {
		return _value;
	}
}