These examples use the fetch_feed() function of WordPress because I built the page they are taken from inside of the Wordpres framework. This function uses the SimplePie library, so if you’re building outside of WordPress most of the syntax will work the same with only a small bit of plugging-in.

First, let’s just pull a feed.

<?php
if(function_exists('fetch_feed'))
{
	include_once(ABSPATH . WPINC . '/feed.php');  // include the rss reader functionality
}
$feed = fetch_feed("http://speakingcode.com/feed"); // specify the source feed
$feed->set_cache_duration(240); //set cache rate, in this example 4 minutes (240 seconds)
$limit = $feed->get_item_quantity(5); // specify number of items to fetch, in this case 5
$items = $feed->get_items(0, $limit); // create an array of feed items
			//create a link to the feed source's site,using its title
			echo '<a href="' . $feed->get_permalink() . '" title="' . $feed->get_title() . '">' . $feed->get_title() . '</a><br>';
			//output error msg if feed no results are present
			if ($limit == 0) echo '<div>The feed is either empty or unavailable.</div>';
			else
			{
				//print out a list of items for the feed
				echo '<ul>';
				foreach($items as $item)
				{
					echo '<li>';
					echo '<div><a href="' . $item->get_permalink() . '" title="' . $item->get_title() . '">' . $item->get_title() . '...</a></div>';
					echo '</li>';
				}
			echo '</ul>';
			}
		}
	}
}
?>

That’s simple enough – we call fetch_feed() with the url of the feed, which returns a feed object that we store in $feed. Then we have simple methods like get_items(), get_permalink(), get_title(), etc. to grab data about the feed, which we can easily display on the screen.

Now lets use some MySQL to pull feeds from a table instead of providing a hard-coded URL. We’ll use a table named ‘feeds’ with ‘name’ and ‘feed_url’ columns. This will allow us to use custom names instead of being tied to the provided name of a feed, which often is lengthy or otherwise not what we want (for instance, “RSS Syndication feed for example.com” vs. “example.com’s latest”). We’ll wrap it into a loop so that we don’t have to duplicate code for each feed…

<?php
if(function_exists('fetch_feed'))
{
	include_once(ABSPATH . WPINC . '/feed.php');  // include the required file
	include_once(ABSPATH . '/config.php');  //include dbase config
}
//connect to database
mysql_connect("localhost", $username, $password) or die(mysql_error());
mysql_select_db($database) or die(mysql_error());

// Retrieve all the data from the "feeds" table
$result = mysql_query("SELECT * FROM feeds ORDER BY name") or die(mysql_error());  

while($row = mysql_fetch_array($result))
{
	$feed = fetch_feed($row['feed_url']); // specify the source feed
	$feed->set_cache_duration(240);
	$limit = $feed->get_item_quantity(5); // specify number of items
	$items = $feed->get_items(0, $limit); // create an array of items
	//title as link to feed source
	echo '<h4><a href="' . $feed->get_permalink() . '" title="' . $feed->get_title() . '">' . $row['name'] . '</a><h4>';
	if ($limit == 0) echo '<div>The feed is either empty or unavailable.</div>';
	else
	{
		echo '<ul>';
		foreach($items as $item)
		{
			echo '<li>';
			echo '<div><a href="' . $item->get_permalink() . '" title="' . $item->get_title() . '">' . $item->get_title() . '</a></div>';
			echo '</li>';
		}
		echo '</ul>';
	}
}
mysql_close($connection);
?>

Alright, nothing too difficult, just wrapping up in a little loop and dropping in some basic MySQL interactions. This will give us a nice, long list of all of our feeds and their items, but it won’t be pretty. Let’s jazz it up…

First, we will use a simple loop to create a “navigation” on the top, which will show every letter in the alphabet as a link to an anchor area within the page (<a name=”something”>… ;  <a href=”#something’>…). Then we will wrap our feed loop inside another loop, which passes through the alphabet again, to separate them into anchor sections based on the first letter of their title (alphabetical order)…

<?php
//links to each section (by alphabet)
echo '<h3>| ';
for ($i=65; $i<90; $i++)
{
	echo '<a href="#' . chr($i) . '">' . chr($i) . '</a> | ';
}
echo '</h3>';

if(function_exists('fetch_feed'))
{
	include_once(ABSPATH . WPINC . '/feed.php');  // include the required file
	include_once(ABSPATH . '/config.php');  //include dbase config
}
//connect to database
mysql_connect("localhost", $username, $password) or die(mysql_error());
mysql_select_db($database) or die(mysql_error());

//display entries with alphabetized breakdown
for ($i = 65; $i < 90; $i++) //for each letter in alphabet
{
	$result = mysql_query("SELECT * FROM feeds ORDER BY name") or die(mysql_error());
	echo '<tr><td valign="top" align="left"><a name="' . chr($i) . '"></a><h3>' . chr($i) . '</h3></td></tr>';
	$position = 0;
	while($row = mysql_fetch_array($result))
	{
		if ($row['name'][0] == chr($i)) //if name of feed starts with the current letter we are in
		{
			echo '<td style="padding:10px;" valign="top" align="justify">';
			$feed = fetch_feed($row['feed_url']); // specify the source feed
			$feed->set_cache_duration(240);
			$limit = $feed->get_item_quantity(5); // specify number of items
			$items = $feed->get_items(0, $limit); // create an array of items
			//title as link to feed source
			echo '<h4><a href="' . $feed->get_permalink() . '" title="' . $feed->get_title() . '">' . $row['name'] . '</a><h4>';
			if ($limit == 0) echo '<div>The feed is either empty or unavailable.</div>';
			else
			{
				echo '<ul>';
				foreach($items as $item)
				{
					echo '<li>';
					echo '<div><a href="' . $item->get_permalink() . '" title="' . $item->get_title() . '">' . $item->get_title() . '...</a></div>';
					echo '</li>';
				}
				echo '</ul>';
			}
		}
	}
}

mysql_close($connection);
?>

 Now that we have sections, we can clean them up. Using a variable as a counter, we can use modulo n to divide sections into n columns. We’ll declare a table outside of the loop, which will encompass all of the feeds. We’ll open a table row with the first item, and for every n items, we will close a table row and declare a new one. After we loop through the elements, we’ll make sure to close the last item if it wasn’t the n’th in its row, and close the table. In addition, we will use the substr() function (substring) to truncate the titles of feed items so that we get a nice uniform look.

Before I show that, let’s do one more modification. A common source of active feeds is Twitter, but we like to denote those feeds with # and @ at the front of the name, per the Twitter standard. We will modify our “matching character” condition in the if-statement by using this rule: if (first letter is # (hashtag) or @  (at-symbol) AND second letter is the current character) OR (first letter is current character) then display it in this section. Here’s how it all looks, using a 3-column example:

<?php
if(function_exists('fetch_feed'))
{
	include_once(ABSPATH . WPINC . '/feed.php');  // include the required file
	include_once(ABSPATH . '/config.php');  //include dbase config
}

//connect to database
mysql_connect("localhost", $username, $password) or die(mysql_error());
mysql_select_db($database) or die(mysql_error());

//links to each section (by alphabet)
echo '<h3>| ';
for ($i=65; $i<90; $i++)
{
	echo '<a href="#' . chr($i) . '">' . chr($i) . '</a> | ';
}
echo '</h3>';
//open table
echo '<table>';
//display entries with alphabetized breakdown
for ($i = 65; $i < 90; $i++) //for each letter in alphabet
{
	$result = mysql_query("SELECT * FROM feeds ORDER BY name") or die(mysql_error());
	echo '<tr><td valign="top" align="left"><a name="' . chr($i) . '"></a><h3>' . chr($i) . '</h3></td></tr>';
	$position = 0;
	while($row = mysql_fetch_array($result))
	{
		//if first letter matches current char, or if the first letter is #/@ and second letter matches current char
		if ( ( ($row['name'][0] == "#" || $row['name'][0] == "@") && strcasecmp($row['name'][1], chr($i)) == 0 ) || (strcasecmp($row['name'][0], chr($i)) == 0) )
		{
			if (($position % 3) == 0) echo '<tr>';
			echo '<td style="padding:10px;" valign="top" align="justify">';
			$feed = fetch_feed($row['feed_url']); // specify the source feed
			$feed->set_cache_duration(240);
			$limit = $feed->get_item_quantity(5); // specify number of items
			$items = $feed->get_items(0, $limit); // create an array of items
			//title as link to feed source
			echo '<h4><a href="' . $feed->get_permalink() . '" title="' . $feed->get_title() . '">' . $row['name'] . '</a><h4>';
			if ($limit == 0) echo '<div>The feed is either empty or unavailable.</div>';
			else
			{
				echo '<ul>';
				foreach($items as $item)
				{
					echo '<li>';
					echo '<div><a href="' . $item->get_permalink() . '" title="' . $item->get_title() . '">' . substr($item->get_title(), 0, 60) . '...</a></div>';
					echo '</li>';
				}
				echo '</ul>';
			}
			echo '</td>';
			if (($position % 3) == 2) echo '</tr>'; //close the row after every three elements
			$position++;
		}
	}
	if (!(($position % 3) == 0)) echo '</tr>'; //close row after final element if it wasn't the 3rd in its row.
}
echo '</table>';
mysql_close($connection);
?>

There ya go. With hefty yet straightforward pair of nested loops, we get a nice, clean RSS aggregate sorted alphabetically, which handles twitter-esque hash tags and @ signs. This makes a good starting point for all sorts of customization… enjoy!

Google is the most used search engine, so naturally, optimizing for Google is the best bet. Unfortunately, Google’s engine (called Panda) is always being tweaked and modified to make it “better”, prevent abuse, etc., so SEO is an on-going game. Some particular SEO voodoo will lose its glitttering value as changes are made, but in general, a good SEO strategy will remain valid for a long time.

So how does Google rank pages? Very few people know exactly how for certain, but its sort of known at a high level. Their servers crawl the web and keep a record of all the words on every page crawled. Additionally, for every page, the engine keeps track of how many links to that page it finds on other pages. The general idea is that the more people decide to link to a particular page, the more useful its content probably is. When a user searches for a term, it pulls every page that contains that term (and probably variations of the term and closely-related terms) and then orders them based on several criteria, such as strength and frequency of match (how often does the keyword appear in content of the page?), estimated relevance, number of backlinks, quality of content (is it gibberish, is it unqiue or duplicated from elsewhere, etc.) and other factors. To what extent each factor matters is not certain and it changes pretty often. Some criteria (for instance meta-keywords, at the time of this writing) are overlooked completely, and others are hard to describe (such as statistical pattern matching on how “good” a site is based on user-driven seed data). I suspect Google also looks at your cookies and tries to order results based on “personalized matches”.

The complexity of SEO and the ever-changing rules to follow make it daunting, but there are good approaches that keep things simple and maximize impact for the least effort. Good SEO and marketing is built into a site from the ground up, so we’ll talk about SEO in phases. It isn’t necessary for each phase to be done in a certain order or for each to be done at all, but for this article we’ll assume starting from the beginning on a new SEO-optimized site.

Phase 1 – Keywords

SEO is all about keywords: choosing the right keywords to target and targetting them in the right way, in every way feasible. You have an idea for a great new website or web business. Awesome. First things first, you need to find out the best keywords around the domain the website targets (not .com domain, business domain!). Use Google’s AdWords tools (free) to find which terms (relevant to your site) are the most searched for. Suppose you’re planning to launch a site to sell your home-grown coffee beans. You might check “buy coffee”, “purchase coffee”, “home grown coffee”, “buy coffee beans”, “order coffee”, “order coffee beans”, etc. Look for the search terms (sometimes they are phrases, not just one word) that are relevant, have the highest number of searches and the lowest amount of competition (when possible). AdWords tools will suggest similar terms based on the ones you check, so utilize those features.

If you’re targetting a particular area or region, you should include it in the terms you check, for instance “buy coffee in Memphis”, “Memphis coffee”, “Memphis coffee beans”, and so forth. Get a list of the 5 to 7 strongest relevant search terms; we’ll be baking them into every part of the site we can very soon. In a competitive industry (which most are in the online world), there will be other sites targeting the same keywords and phrases. You can use tools like those on spyfu.com to research your successful competitor’s targeted keywords and do other analysis to succeed the same way they do.

Phase 2 – Branding

Choose a good name for your site. What’s a good name? One that is short, easy to remember, easy to spell, catchy, and with availability. If you can include one or more of your targetted keywords, even better! You’d be surprised how much more effective a search-optimized name like “Cheap Coffee Deals” or “Buy Coffee Fast” might be over a cute pun like “Java Jam” or “Beans-n-Things” (assuming ‘cheap coffee deals’ or ‘buy coffee fast’ are strong keywords). And by availability, I mean not just available as a brand name, but in .com form, and on all social networks and user sites. If the .com form of your name is already taken, choose a new name. Sometimes you can do “domain hacks” like del.icio.us and bit.ly, but in general most people remember and type in “whatever.com” when they are looking for a brand’s site. You’ll want to set up accounts on every social network, link baord, and content-share you can think of – Twitter, Facebook, Delicious, Reddit, Tumblr, StumbleUpon, Google+, YouTube, Vimeo, etc. – and use the same name for all of ‘em. Suppose for our made-up coffee example we decided the name “Memphis Coffee”. We want memphiscoffee.com, twitter.com/memphiscoffee, facebook.com/memphiscoffee, memphiscoffee.tumblr.com, youtube.com/memphiscoffee, and so on. The availability of words gets less and less with every passing second, so sometimes it’s hard to have a consistent name across all channels… do your best, but don’t get too hung up if you have to use variations on some channels – it’s impossible to avoid sometimes. Don’t spend too much time – phase 1 and 2 can be done in a day (and often are, even for big successful startups) – getting to market is more important than having the “perfect” catchy name.

Phase 3 – Optimize for Keywords

We have our 5 or so strongest terms, and we have a brand name with a matching .com and account names on the popular social networks, hopefully with some keywords included in it. We need to pump our keywords/phrases into our site in every way possible, as we build it – in the content, in meta tags and descriptions, in page titles, in filenames, in urls, in HTML attributes, in image captions, etc. What, that sounds difficult to maintain? Are you using a CMS (content management system) like WordPress or Drupal to build your site? If not, you probably should consider it (unless you’re going to be dumping big dollars into a custom built site and lots of advertising to make up for the lack of SEO-friendliness). Also, we want to keep our titles and descriptions down to 140 characters or less. Most search engines only read and display the first 140 or so characters; we want to catch both the search engine and the user reading results in one punch, so keep them short and include keywords. Suppose our prime keywords are “buy coffee”, “order coffee”, “buy home grown coffee”, “memphis grown coffee”, and “order coffee beans online” A snippet of very basic SEO-optimized HTML might look like:

<html>
<head>
<title>Buy home grown coffee beans from Memphis Coffee. Order coffee, buy home grown coffee, Memphis grown coffee, order coffee beans online</title>
</head>
<body>
<a
  href="memphiscoffee.com"
  id="banner-link_mempis-coffee_buy-coffee-order-coffee-buy-home-grown-coffee-memphis-grown-coffee-order-coffee-online"
  title="Buy home grown coffee beans from Memphis Coffee. buy coffee, order coffee, buy home grown coffee, memphis grown coffee, order coffee beans online">
<img
  src="banner_memphis-coffee_buy-coffee-order-coffee-buy-home-grown-coffee-memphis-grown-coffee-order-coffee-online.png"
  alt="Buy home grown coffee beans from Memphis Coffee. buy coffee, order coffee, buy home grown coffee, memphis grown coffee, order coffee beans online"
  title="Buy home grown coffee beans from Memphis Coffee. buy coffee, order coffee, buy home grown coffee, memphis grown coffee, order coffee beans online"
  id="banner_mempis-coffee_buy-coffee-order-coffee-buy-home-grown-coffee-memphis-grown-coffee-order-coffee-online">
</a>
<br>
<br>
<p>
Welcome to Memphis Coffee, where you can buy and order home grown coffee and Memphis grown coffee, order coffee beans, and more.
<a
  href="memphiscoffee.com/store_mempis-coffee_buy-coffee-order-coffee-buy-home-grown-coffee-memphis-grown-coffee-order-coffee-online.php"
  id="store-link_mempis-coffee_buy-coffee-order-coffee-buy-home-grown-coffee-memphis-grown-coffee-order-coffee-online"
  title="View the Memphis Coffee store. Buy coffee, order coffee, buy home grown coffee, memphis grown coffee, order coffee beans online">
See our store</a> to check out our huge variety of coffee beans as well as fresh-ground home grown coffee...
</p>
</body>
</html>

Now of course this example is a bit over-the-top in that the actual content is lacking and has little substance other than the overhaul of SEO, and the tacky overkill of keywords in the text. Consider it exaggeration for the sake of emphasis, but don’t be fooled – having the keywords in all those attributes and titles is the goal. Inject them everywhere. Be sure to balance it with lots of actual meaningful content (and be subtle in how you sneak your top phrases in – a common trend is to put them in the page/post name, in the first paragraph, and in the last paragraph). Speaking of content…

Phase 4 – Content, Content, Content

In the web world, content is king, and SEO is no exception. Without good content (and at least a decent presentation) most people won’t read your site, they won’t come back to your site, they won’t recommend it or share it, and they’ll likely be weary of buying any products. Search engines share this sentiment, and favor sites with lots of content that is filled with words and updated regularly. How regularly? Most SEO experts seem to agree that you should strive to update daily; at the very very minimum, a couple of times a week. This phase could easily be called “UPDATE UPDATE UPDATE!” In terms of SEO, it’s not about changing your design and layout, reworking your CSS or any of that.. it’s about adding content, and in that meaty content – inject your prime keywords.

Blogging is a wonderful way to keep your content growing and your target audience finding you. Some benefits of blogging:

• Each blog post is an update. Google likes updates. It’s like telling the engine, “Come back and look at me, I have something new to share with the world!”
• Each blog post adds content. Google likes lots of content. The more you feed the hungry monster, the better off you’ll be. Not to mention, it’s easy to cleverly sneak some or all of your targeted  keywords into each post without being obnoxious.
• Blog articles are typically dated and most blog platforms support organizing your articles by date (among other topology). This is a great way to present time-sensitive information (like a sales announcement) in a place where it can stay forever. Imagine updating sales or news on a static page – every time something expires, you’d have to take it down and put something else in, losing all that valuable content and handling tedious changes.
• Users like blogs. Marketing, especially online, is all about connected-ness these days. Users like to comment on articles and share the latest news with their friends (which helps generate back-links to your site). They like to have dialogue with people from the company/brand/service, one in which they have input on the direction of the company. They like to see updates from the company, as it gives the impression that the company is alive and active and engaging… all this helps build brand loyalty, which is very important for businesses.
• Each article adds pages. Most blog systems (like WordPress) dynamically generate index pages, archive pages, category listings, etc. for the articles, and each article amounts to at least 1 (if not several) pages being created or modified with the contents of the article. Google likes big sites with lots of pages, and it really likes when there’s a nice web of internal linking among pages on a site… content and links are like air and water for the search engines, so this means SEO feeding frenzy.

It gets clear that using a CMS to help manage files, pages, links, indexes, and so on becomes more than necessary. Copying and pasting is a useful tool as well, but imagine doing this kind of “keyword injection” in several pages on a regular basis, updating indexes, updating internal links, etc. etc. etc. by hand – it will make your head spin and you’ll die of cranial explosion. So find a good CMS like WordPress (my preference), SquareSpace, Joomla, or Drupal and master it – you’ll never look back.

Phase 5 – Backlinks and Sharing

This is the hardest part of SEO because, ultimately, it depends on other people putting links to your site somewhere. But you can take steps to encourage and streamline the process so that people are more inclined to share your site to others.

Remember all those social network accounts you setup in the branding phase? I hope you’ve been steadily adding friends and engaging the communities. Every time you post a new article on your blog, add a new page, a new section, new feature, whatever – post a link on every single social network you have. Ideally people will like what they see and repost it on their account (Re-tweet, Share, +1, Like, Digg, Thumbs Up, etc.) The 140 character titles and descriptions come handy here, because many social networks limit the length of posts. Be sure to follow the proper etiquette of each individual service – don’t be a spammer or appear only concerned about driving traffic for yourself, as people catch on and generally hate it. Engage genuinely in discussions about topics relevant to your business and people will credit you as a knowlegeable player in that field.

In addition to using social channels to spread the word about your updates (which builds back-links and encourages others to do so for you), you can use tools to encourage users to share your content from within your site. Most social networks have a general URL you can use to automate sharing, like www.whatevernetwork.com/share.php?name=CoolSite&url=memphiscoffee.com. Put links to those on every page and post so that your users can just click one link and automatically share it on the corresponding network without hassle. WordPress (and probably other blog-based CMS platforms) have plugins that will automatically do this for dozens of social networks on every single page and post on your site. Use them.

There are link building services online that will submit links to your site on many directories and sites. These range from free to costly and from very legitimate to extremely unethical (and sometimes even criminal). Several sites exist as link directories and indexes, link trading networks, etc. and it’s good to be on them, though often not very effective. On the other end are tools and services that spam links on every comment box they can find on the web, or generate tons of zero-content “link farm” sites that exist soley to build backlinks to a particular site. Google’s Panda engine is made to spot link farms and will even derank pages that are link farmed. Not to mention, a lot of the shady link building services are ran by con artists and criminals of very questionable character; not all, but many. So be careful in that area.

Wasn’t that simple? That’s it, you’re done. NOT! The last component to a good SEO strategy is continuity. Google changes their engine in various ways pretty regularly, and most other search engines follow their model. SEO requires regular maintenance and investigation into the latest tricks of the trade, the latest trends in your market, etc. Persistence is the key. If your site has quality content that is updated regularly, and if you engage the online world in several social channels, you’ll do alright. Not every good site or service goes viral, but most of the decent ones, following these basic optimization guidelines, will catch on and get good traffic from search engines before long.

Bear in mind, these are just some basics of SEO, which is a pretty extensive field of ongoing research and development, shifting approaches, endless tools, and myriad details. You can get books and find sites online to go deeper into the subject, these are just the basics. Good luck!

Seriously, though, what makes the site cool is the focus on video content. Whether it’ a tutorial, a demonstration, whatever, James (the founder) is serious about getting an informative video up on the site every single day, along with regular articles steadily pouring in. I’ve written a couple myself, including one on how to run Andriod apps on Windows and another about John McAffee getting arrested for gun and drugs charges. So in short, GeekBlog.tv is an awesome site with focus on fresh, relevant, QUALITY content. No fluff, no overdone SEO padding, no swimming through rivers of generic statements to find the meat… so check it out and learn some good tips and info. While you’re at it, follow @geekblogtv on twitter!

Good ole technology makes spreading a cause... too easy?

In recent months, viral online campaigns have had tremendous results in raising public awareness, putting pressure on companies and governments, and effecting actual change in policy and practices. Besides getting the word out on social networks, new ways of joining a cause are emerging. Online activism sites are springing up left and right, some dedicated to specific agendas, others generalized for all sorts of issues. Start or sign a petition. Orchestrate an email campaign. Coordinate a protest. Gather resources…  Fighting for a cause is no doubt becoming easier to carry out, but as online activism becomes trendy, its efficacy may suffer…

Recent campaigns range from stopping legislation such as SOPA/PIPA, pressuring companies like Walmart and Target to treat employees better, and even changing outcomes of police investigations such as the Treyvon Martin case. A number of campaigns, like the ones mentioned, seem to be successful in achieving their intended goal, but their success may have largely depended on social circumstances, circumstances which are quickly changing.

The Opposite of Unity is Division

Let’s consider the “competition” angle. As multiple services compete to be the place for online activism, the number of active users on any given service will decrease. Some will go here, some will go there, some will go elsewhere. Although seemingly minor, the big stick wielded by online activism is the power of sheer volume and the ability to demonstrate that masses of people feel a certain way around an issue in a hard-evidenced, factual number. While politicians and decisions makers surely make efforts to keep their ears open to the buzz of “what’s going on in the public”, their decisions are much more influenced directly by numbers which show how their constituents, customers, etc. actually side. One source saying “X million actual people sided this way” has a bigger impact than few sources saying “X thousand people sided this way”.

In terms of petitions, it becomes harder (though not impossible by any means) for any one petition to grow to impressive size when there are multiple petitions on the same issue. It doesn’t mean they don’t have any value or weight, but consider this: Senator A gets a petition on some issue with 10,000 signatures. Maybe it catches his attention, but from a senator’s point of view 10,000 online signatures probably doesn’t seem significant. “How many are valid? How many are registered voters? How many are my own constituents? Is the issue that big?” Senators B, C, D, and E get petitions on the same issue with another 10,000 signatures each, and have the same sentiment. But what happens when a senator gets a petition with 50,000 signatures? “Maybe I better call Bob, Bill, and John and talk about this.” The impact of a huge number of signatures going to one “bigwig” can be greater than several disparate petitions reaching several bigwigs.

Ongoing disruption is noise, and noise gets tuned out.

Take to the streets! Our voices must be heard.

Another angle of concern is “crowding” – things don’t stick out as much when everyone does it. As activism becomes trendy, more issues get pushed. More campaigns, more petitions, more emails, more tweets.. it becomes harder for important issues to gain momentum when they are overshadowed by myriad issues of lesser significance. We’ve all gotten the endless followups from change.org and the like, asking us to join one cause after the other. Soon enough, we ignore them, or a filter sends each and everyone to the trash bin upon arrival.

Crowding can also have an adverse effect on the reactions that campaigns get from the people they target. Campaigns start to get common and lose the shock value. Issues degrade into bitch-sessions about return fees, inconvenient hours, costs, and other concerns which, although valid, probably don’t demand national attention and outcry. Frankly, it turns into annoyance at best. Think about all the customer-feedback channels: phone numbers, emails, comment boxes, etc. that get flooded with so much garbage that companies hardly bother reviewing them. Those petition letters that made Senator John Doe panic and say “Oh crap!” start going straight to the trash bin as well.  They stop taking the activism AND the activists seriously. They question whether these people will really take action, or are they content with signing one “spam cause” after the next.

It's hard to ignore this every day.

Perhaps activism is becoming too easy. What can we, the people, do to prevent a fruitless convolution from becoming the status-quo? That’s difficult to say, but there may be a few easy-to-follow guidelines to help our protests and campaigns.

• Limit the number of causes we try to put out to the masses through online campaigns – keep the channels clear for the stuff that’s significant, like real threats to our freedoms/rights, humanitarian abuses, and scams and malpractice which could tremendously harm society and the public.
• Send paper letters. It’s just as easy to delete an e-petition with a million signatures as it is to delete an offer for free pharmaceuticals (well, maybe that’s difficult for some people), but it’s not so easy to get rid of a million paper envelopes pouring into the mailbox. Not only do tangible materials have a physical bearing, but the time and effort it takes to write, print, envelope, stamp and send a paper letter (though miniscule) is typically more appreciated by public officials, public relations reps, and upper management. Not to mention, it’s revenue for the precious postal system, which is struggling to stay afloat these days.
• Take real action. Make phone calls. Put up fliers and posters. Deliver informative handouts and pamphlets to people.  Take to the streets for peaceful demonstrations. The power of a massively aligned online community is slim in comparison to an active populace. Use the Internet to spread the word and raise awareness; don’t pat yourself on the back as an activist for re-tweeting and clicking a few buttons.

We are in a precious period where the masses are once again being recognized by the elites as a dynamic force which is capable of organizing, aligning, and demanding change. It is absolutely crucial, while we have their attention, to show that we can foster this momentum into productive action. Good luck, comrades!

This article is focused on one particular, narrow, but highly-important aspect of security: anonymizing your Internet traffic. Really, that’s a broad topic in and of itself, thus the narrow indicates that we probably aren’t covering everything. Don’t go acting stupid and thinking these steps make you invincible!

Among others, Arch is a Linux distro I love. There are many distros, with their pros and cons, their ups and downs, their quirks, their special purposes, and so forth. I’m definitely not saying Arch is the end-all of distros, but I find it to be quite excellent as a general-purpose, day-to-day desktop dsitro. So this tutorial uses commands based on the Arch package manager, pacman. If you don’t use Arch, compile from source or rtfm on your distro and use whatever package manager and configurations it has.

First, let’s create a fresh user. This gives us a fresh start in terms of user settings, and a sort of silo to play and experiment with privacy-intensive configurations without affecting our general-use user.

# useradd -m -g users -G audio,lp,optical,storage,video,wheel,games,power,scanner -s /bin/bash someuser

Now we want to add the wheel group to the sudoers file so that our new user can perform root tasks using sudo when needed. Type in:

# EDITOR="nano" visudo

and add the following line:

%wheel ALL=(ALL)

Great. Now our new user, “someuser” in this case, can perform commands as root using sudo. Lets get started.

First, we want to install tor. Tor is an onion-routing based proxy used to anonymize your browsing. Basically, each person running tor is also a node on the tor network. Your tor client connects to a central server, gets a list of a couple of random nodes, and routes your traffic through those nodes. Each node has a public key, so your client encrypts your data multiple times, using each node’s key, in reverse order. So your data is encrypted for the last node first, then the second node, and finally encrypted for the first node. Then, each node decrypts its layer (thus onion routing) before passing your data to the next node. Once the data reaches the last node, called the “exit node”, it is back in its original, unencrypted form.

At this point, it’s quite difficult for anyone to determine where the data originated, unless of course the data itself contains information about the originator. End-to-end encryption is used between each hop for added protection, but again the data is back in its original form when leaving the last hop of the tor network and going back out to the public web. Use https and other end-to-end encryption between you and your recipient to protect sensitive data.

So, tor will help protect your incoming and outgiong data (routed through tor) from someone watching your outgoing infromation, like your ISP or a man in the middle. Data is encrypted at the application layer multiple times, so it’s pretty damn safe through the tor network until it hits the exit node. Keep in mind, you don’t know who the exit node is or who is watching it, and data is back in its original form at the exit node. If the data itself contains information that could link back to you, like name, address, location, email, accounts, and other personal identifiers, someone could read through the data and know it’s yours and what you’re sending/receiving. From a purely technical standpoint, though, there isn’t a very feasible way to trace the data to its origin in the transport or internet layers.

First, install tor:

$sudo pacman -S tor

Now  enable Tor DNS forwarder , this will allow tor to resolve your DNS hostnames through the tor network, helping to keep your browsing habits secret. (This resolves only A records):

#nano /etc/tor/torrc
 | DNSPort 9053
 | AutomapHostsOnResolve 1
 | AutomapHostsSuffixes .exit,.onion

restart tor:

#/etc/rc.d/tor restart

Now that tor is configured and running, we can configure applications to pump their data through it. In our browser, for instance, we can go to the network settings and run traffic through tor’s locally-running socks 5 proxy server:

127.0.0.1:9050

Some applications do not have options exposed to manually set a proxy to go through, so we can use tor-resolve and torrify on those. tor-resolve will resolve DNS records for domains (currently only A records), as DNS resolving itself happens independent of applications and can be telling of the sites we are visiting. torrify acts as a sort of wrapper around an application so that its network activity runs through tor. Here is an example using BitchX:

#tor-resolve <irc.server.domain>
#torify BitchX

Tor provides a pre-packaged Tor Browser which runs inside of a tor sandbox and comes bundled with Vidalia, a GUI tool for managing tor. Currently, a modified firefox setup is used, with NoScript and other plugins installed to prevent JavaSript, cookies, and so forth from leaking identifying information. Furthermore, it can be set (and is by default) to force sites to use https for end-to-end application-layer

$tar -xf tor-broswer.tar.bz
$cd ./tor-browser
$sudo ./start-tor-browser

NOW YOU CAN START READING ONLINE SAFELY

Using tor, we get a nice layer of obfuscation that makes it very difficult (though theoretically possible) for anyone in the network to monitor our data and see what we are doing by sniffing network packets, and at the same time anonymizes us on the outside so that potentially malicious or invasive intruders on the other end cannot gather personalized information on us, such as our IP addressand hostname, which could be used to identify or locate us, among other things.

Here’s a few things to remember about tor:

• tor’s efficacy largely depends on the number of nodes in the network. More nodes mean more random paths between nodes are possible, increasing the complexity of tracing the origin and reducing the feasability of theoretically possible attacks based on having a holistic view of the tor network. Also, because all traffic is encrypted in multiple layers and sent through multiple nodes, using tor can be slow at times. That said, be nice and give back by allowing tor to run even at times you aren’t using it, acting as a node for other people’s encrypted traffic to pass through. Additionally, don’t use tor for heavy data transfer – bit torrent and the like is typically frowned upon.
• Exit nodes, and the people running running exit nodes (which is set by choice, not default) , are exposed to the outside internet. While historically not very problematic, it does put them in a position of risk as any data exiting from a given node can be linked to the person running it by his/her ISP. While it may not hold against them in court, it can put them in violation of the law, or their isp’s terms of use, if other torizens abuse the network. Don’t use tor to do anything illegal, unethical, or which might cause problems for an exit node operator. Use it to protect your right to privacy as a law-abiding citizen and your right protection from snoopers, scam artists, advertisers, and the like.
• Tor is only one layer of obfuscation- data goes back to the public net in the same form that it came into tor. If you send out data which includes information that is not encrypted at the application layer, someone outside of the tor network can read it. Use end-to-end encryption in addition to tor, such as gpg, to protect transmissions between yourself and a known recipient, or use https to get end-to-end encryption over http.

Fusion tablet/notebooks with multi-touch support are coming, and it looks like Windows 8 will be the host.

Intel announced yesterday that 75 Ultrabook models are under development. “Ultrabook” is Intel’s trademark description of notebook-type devices that specifies certain requirements for weight, thickness, battery life, time-to-wake, etc. Manufacturers have to meet the spec guidelines in order to label a product as an Utlrabook.

Of the new models, most or all of them will have touchscreens and several models will be tablet hybrids. Several screen sizes are included in this lineup, ranging from under 13 inches to over 15.  Intel also expects that some models will reach starting prices as low as $699.

Windows 8 looks to be the choice operating system to roll out with this next generation of Ultrabooks. This is a big deal for Microsoft as it will instantaneously bring strong market penetration into the tablet/touchscreen sector, assuming consumers purchase these new models. With new features like multi-touch screens, and with the low-weight, fast-boot, slim-design requirements enforced by Intel, it’s probably safe to bet that reception will be good.

This is good news not only for Microsoft and Intel, but also for developers who are jumping in with Windows 8 Metro development. We all know Microsoft doesn’t hurt for market share on traditional desktops and notebooks, but the mobile and tablet world is a different ecosystem, with more players and rapid changes. With Windows Phone receiving less-than-sizzling response from the masses, it was unclear if and how Microsoft would come in as a formidable competitor in the mobile world, and how Windows 8 would fair as a sort of “fusion” tablet/desktop OS. Will desktop and notebook users care about light-weight, “consumption” based, touch-enabled apps in an envrionment typically reserved for feature-rich, complex productivity suits?

Manufacturers are swooping in on the Ultrabook concept, blurring the lines between notebooks and tablets and pushing the categories of mobile computing.  This will likely get Windows 8 into the hands of many consumers who are interested in using devices in a mobile and/or touch-centric modality and thus will embrace the Metro platform, making it worth the time and costs for Metro app developers. At the very least, there will be no shortage of devices for their creations to run on.

How will this change the spectrum in consideration of Apple and Android? This will be the really interesting thing to watch. Android seems to be less than dominant in the tablet market, but it looks like Microsoft is coming full force. Will the “seamless experience” Win 8 provides across desktop, notebook, and tablet pull users away from Apple and Android tablet devices? My guess is that Microsoft plans to extend the Win 8 “unification” to the phone not far down the road, which may drive a lot of consumers to a Windows phone in the future.

Speaking of Windows 8 Metro development, I have started to dabble in that area just a tad. Expect more posts with some code details soon!

Ok, so if you don’t know, Scala is a programming language. It’s not exactly new, but it has been gaining momentum and attention for the past couple of years. Being a full time developer in a Java shop, the first thing I did was Google search “Scala vs Java”, which led me to this great presentation by Dan Rosen of Marakana, at a San Francisco JUG meeting (btw, you can view the slides here). The sweet sugary syntax and powerful expressive capabilities he demonstrated were enticing to say the least. Some notes about Scala:

• Compiles to Java byte-code which runs on the JVM
• Fully compatible with Java. Scala can use and extend Java classes, reference Java libraries, etc.
• 100% object-oriented. Everything is an object in Scala, including methods, control structures, expressions… everything.
• Fully supportive of functional programming paradigm (avoiding state and mutable data)
• Clean syntax, powerful control structures (like for/yield, case) that typically “surpass” Java, and powerful compiler inferences

So, enough words. This is not a guide to Scala, go to http://scala-lang.org if that’s what you’re looking for.  Let’s look at some code already. I’m going to borrow an example for quicksort. In Java, quicksort might look like this:

public void quickSort(int[] a, int l, int r)
{
  int i = l;
  int j = r;
  int pivot a[(l+r)/2]

  if (array.length <= 1)
    return;

  while(i <= j)
  {
    while(a[i] < pivot)
      i++;
    while(a[j] > pivot)
      j--;
    if(i < j)
    {
      swap(a, i++, j--);
    }
  }
  if (l < j) sort(a, l, j);
  if (j < r) sort(a, i, r);
}
public void swap(int[] a, int i, int j)
{
  int t = a[i];
  a[i] = a[j];
  a[j] = t;
}

That’s the kind of code that makes you feel all smart and cool when you know what it does, and makes you frustrated as hell if you don’t. If you know quicksort, you can probably look at the code and recognize this is it, but the code itself doesn’t really express the algorithm. It is tough to follow and step through and understand at a high level. Even being fluent in Java syntax, I still have to press my brain a little to follow exactly whats going on

Now, in Scala, we could do this in two ways. Although a cleaner syntax than Java IMO, the imperative-style shows just a tad bit of syntactical difference, so I’m going to skip that and show a functional style.  This comes from Martin Odesrky’s free pdf book Scala By Example (available on the scala-lang.org site).

def sort(a: Array[Int]): Array[Int] =
{
  if (a.length <=1) a
  else
  {
    val pivot = a(a.length / 2)
    Array.concat(
      sort(a filter (pivot >)),
           a filter (pivot ==),
      sort(a filter (pivot <)))
  }
}

Holy hell, I did it from memory! The people who worked hard writing and understanding Java implementations of quicksort just got their feelings hurt! Coming from an imperative background, the syntax will look a bit strange, but a few things should stand out clearly.

First of all, this is a recursive function. We are defining a method called sort, which makes calls to itself.  We see a base case,  and we see that we are concatenating the results of the recursive calls. Without knowing any Scala syntax, and despite this example being chock-full of shorthand, it’s not a stretch to decipher that we are breaking our problem into three smaller ones and joining them back together. If you know quicksort, it’s plainly obvious: set a pivot value; break the array down into sub-arrays, one with elements less than the pivot, one with elements equal to the pivot, and one with elements greater than the pivot; sort them and join them back together. We only sort the first and last, as the middle sub-array’s elements are all equal to pivot and thus to each other (a = c, b = c -> a = c).

In Scala, methods that take one argument don’t have to be written as object.method(arg), we can simply write object method arg. This is demonstrated by the + operator: x + 5 is the same as x.+(5) (it turns out that in Scala, we can name methods using special characters like +, -, *, etc.). So a filter (pivot >) is equivalent to a.filter(pivot >)

The filter method of the Array class is one such method, which takes a function as its one argument. This isn’t like java, where we wrap a method with return type A as an argument for another method whose parameter is also type A, and the first method’s evaluation becomes the argument, such as in System.out.println(something.toString()). Rather, the function itself is an object that is being passed through. The filter method has a signature that places constraint on the function it accepts as an argument: it must take a value of type T as input and return a Boolean. Array.filter’s signature looks something like this:

def filter(p: T => Boolean): Array[T]

which defines the function argument, as p, and states that p maps a T object to a Boolean value. In our case, our array is type Int, so we pass a Boolean function that takes an Int as input. We use a shorthand, (pivot >), which is equivalent to (x => pivot > x), which says “give me an input x, and I will tell you if x is greater than the value stored in pivot”.

In Java we might see something like this:

sort(
  a.filter(new FilterTest<Int>()
  {
    @override
    public boolean test(Int i)
    {
      if i > pivot
        return true;
      else
        return false;
    }
  })
);

i.e. we call sort, and as its argument (an ArrayList) we call the a.filter() method (which returns an ArrayList), passing as its argument an anonymous class implementation of the FilterTest interface, which implements the boolean test() method. In accordance, the class for ArrayList would have something like:

public Interface FilterTest<T>
{
  public boolean test(T item);
}

public ArrayList<T> filter(FilterTest ft)
{
  ArrayList<T> outputArray = new ArrayList<T>();
  for (T item : this)
  {
    if ft.test(item)
      outputArray.add(item);
  }
}

In Scala we get all of that long filter call, with the anonymous class implmentation of the FilterTest , instead just by saying a filter (value >), awesome. This is just a taste of the power of Scala, which doesn’t stop there. I can’t wait to dive in and learn even more of it.

• http://developer.android.com/guide/topics/media/mediaplayer.html
• http://developer.android.com/reference/android/media/MediaPlayer.html
• http://developer.android.com/reference/android/media/AudioManager.html

The same goes for the android.app.Service class – Android services are on the more complex side of Android app development, and the Service class lends itself to several models of use. Read up on it…

• http://developer.android.com/guide/topics/fundamentals/services.html
• http://developer.android.com/guide/topics/fundamentals/bound-services.html
• http://developer.android.com/reference/android/app/Service.html
• http://developer.android.com/reference/android/content/ServiceConnection.html
• http://developer.android.com/reference/android/os/IBinder.html

So here is the basic approach we will follow. First, we will extend the android.media.MediaPlayer class into a new class that provides a bit of state management (using an enum of states), because the MediaPlayer class involves a lot of state but doesn’t provide any methods to directly get the state (oops!).

Then we will write a Service class that extends android.app.Service to run outside of any Activity, so that music playback can continue when the user leaves (not “exits”) the app. The service will implement some interfaces to get notices from the MeidaPlayer, like when it’s prepared and when it has an error, etc. Additionally, the service will implement an internal, public class that extends android.os.Binder (an implementation of the android.os.IBinder interface), which is used by the Activity/Activities that want to bind to the service to interact with it. An instance of this class is returned by the public IBinder Service.onBind() method which our service will override from its parent Service class. In our case, this internal class will have one method, called getService(), which returns an object reference to the instance of the Service itself. Then the bound Activity can simply make direct method calls on the instance of the service, via the object reference returned by getService().

The “main” Activity that uses the Service will have a private implementation of the android.content.ServiceConnection interface (I think technically this implementation is an anonymous class, but damn those Java terms), which will be passed TO the service (via bindService()) when the Activity binds to it. This will have the onServiceConnected() method where the getService() method mentioned above will be called, and the Activity will pass an object reference to itself BACK to the service, so that the service can call callback methods on the Activity – this will allow the Activity to update controls and displays based on what’s happening with the service and media player – like setting the play/pause button to the right state.

Of course, the Activity will have methods to control playback, as well as show some status to the user. In addition, it will have some helper methods to check, when it starts, whether the service is already running or not, so it will know if it should bind to the existing instance or create a new one. This will allow the user to leave and return to the app freely without interfering with playback.

In addition to those classes, we will have a few more supporting classes. The StreamStation class will represent a station for streaming audio, holding the name and url as members, and having some compare methods we will use in our Activity to determine the currently playing station when we bind to the Service. The StreamStationSpinnerAdapter class will be used to populate the Spinner object we use to select different streams. And lastly, the CONSTANTS class will hold some constants like an array of StreamStation objects…

As mentioned in the disclaimer, this is not a complete solution, but rather a start. There are other things to consider like phone interruptions, sharing the playback device with other apps, and more, which are not addressed in this example. Just a start..

package com.speakingcode.android.media.mediaplayer;

import java.io.IOException;

import android.media.AudioManager;
import android.util.Log;

import com.speakingcode.audio.media.streamStation.StreamStation;

/**
 * A subclass of android.media.MediaPlayer which provides methods for
 * state-management, data-source management, etc.
 * @author rootlicker http://speakingcode.com
 */
public class StatefulMediaPlayer extends android.media.MediaPlayer {
	/**
	 * Set of states for StatefulMediaPlayer:<br>
	 * EMPTY, CREATED, PREPARED, STARTED, PAUSED, STOPPED, ERROR
	 * @author rootlicker
	 */
	public enum MPStates {
		EMPTY, CREATED, PREPARED, STARTED, PAUSED, STOPPED, ERROR
	}

	private MPStates mState;
	private StreamStation mStreamStation;

	public StreamStation getStreamStation() {
		return mStreamStation;
	}

	/**
	 * Sets a StatefulMediaPlayer's data source as the provided StreamStation
	 * @param streamStation the StreamStation to set as the data source
	 */
	public void setStreamStation(StreamStation streamStation) {
		this.mStreamStation = streamStation;
		try {
			setDataSource(streamStation.getStationUrl());
			setState(MPStates.CREATED);
		}
		catch (Exception e) {
			Log.e("StatefulMediaPlayer", "setDataSource failed");
			setState(MPStates.ERROR);
		}
	}

	/**
	 * Instantiates a StatefulMediaPlayer object.
	 */
	public StatefulMediaPlayer() {
		super();
		setState(MPStates.CREATED);
	}

	/**
	 * Instantiates a StatefulMediaPlayer object with the Audio Stream Type
	 * set to STREAM_MUSIC and the provided StreamStation's URL as the data source.
	 * @param streamStation The StreamStation to use as the data source
	 */
	public StatefulMediaPlayer(StreamStation streamStation) {
		super();
		this.setAudioStreamType(AudioManager.STREAM_MUSIC);
		this.mStreamStation = streamStation;
		try {
			setDataSource(mStreamStation.getStationUrl());
			setState(MPStates.CREATED);
		}
		catch (Exception e) {
			Log.e("StatefulMediaPlayer", "setDataSourceFailed");
			setState(MPStates.ERROR);
		}
	}

	@Override
	public void reset() {
		super.reset();
		this.mState = MPStates.EMPTY;
	}

	@Override
	public void start() {
		super.start();
		setState(MPStates.STARTED);
	}

	@Override
	public void pause() {

		super.pause();
		setState(MPStates.PAUSED);

	}

	@Override
	public void stop() {
		super.stop();
		setState(MPStates.STOPPED);
	}

	@Override
	public void release() {
		super.release();
		setState(MPStates.EMPTY);
	}

	@Override
	public void prepare() throws IOException, IllegalStateException {
		super.prepare();
		setState(MPStates.PREPARED);
	}

	@Override
	public void prepareAsync() throws IllegalStateException {
		super.prepareAsync();
		setState(MPStates.PREPARED);
	}

	public MPStates getState() {
		return mState;
	}

	/**
	 * @param state the state to set
	 */
	public void setState(MPStates state) {
		this.mState = state;
	}

	public boolean isCreated() {
		return (mState == MPStates.CREATED);
	}

	public boolean isEmpty() {
		return (mState == MPStates.EMPTY);
	}

	public boolean isStopped() {
		return (mState == MPStates.STOPPED);
	}

	public boolean isStarted() {
		return (mState == MPStates.STARTED || this.isPlaying());
	}

	public boolean isPaused() {
		return (mState == MPStates.PAUSED);
	}

	public boolean isPrepared() {
		return (mState == MPStates.PREPARED);
	}
}

/**
 *
 */
package com.speakingcode.android.media.mediaplayer;

import android.app.Notification;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnBufferingUpdateListener;
import android.media.MediaPlayer.OnErrorListener;
import android.media.MediaPlayer.OnInfoListener;
import android.media.MediaPlayer.OnPreparedListener;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

import com.speakingcode.android.media.mediaplayer.StatefulMediaPlayer.MPStates;
import com.speakingcode.audio.media.streamStation.StreamStation;

import com.speakingcode.example.android.MainActivity;

/**
 * An extension of android.app.Service class which provides access to a StatefulMediaPlayer.<br>
 * @author rootlicker http://speakingcode.com
 * @see com.speakingcode.android.media.mediaplayer.StatefulMediaPlayer
 */
public class MediaPlayerService extends Service implements OnBufferingUpdateListener, OnInfoListener, OnPreparedListener, OnErrorListener {
	private StatefulMediaPlayer mMediaPlayer			= new StatefulMediaPlayer();
	private final Binder mBinder						= new MediaPlayerBinder();
	private IMediaPlayerServiceClient mClient;

	/**
	 * A class for clients binding to this service. The client will be passed an object of this class
	 * via its onServiceConnected(ComponentName, IBinder) callback.
	 */
	public class MediaPlayerBinder extends Binder {
		/**
		 * Returns the instance of this service for a client to make method calls on it.
		 * @return the instance of this service.
		 */
		public MediaPlayerService getService() {
			return MediaPlayerService.this;
		}

	}

	/**
	 * Returns the contained StatefulMediaPlayer
	 * @return
	 */
	public StatefulMediaPlayer getMediaPlayer() {
		return mMediaPlayer;
	}

	/**
	 * Initializes a StatefulMediaPlayer for streaming playback of the provided StreamStation
	 * @param station The StreamStation representing the station to play
	 */
	public void initializePlayer(StreamStation station) {
		mClient.onInitializePlayerStart("Connecting...");
		mMediaPlayer = new StatefulMediaPlayer(station);

		mMediaPlayer.setOnBufferingUpdateListener(this);
		mMediaPlayer.setOnInfoListener(this);
		mMediaPlayer.setOnPreparedListener(this);
		mMediaPlayer.prepareAsync();
	}

	/**
	 * Initializes a StatefulMediaPlayer for streaming playback of the provided stream url
	 * @param streamUrl The URL of the stream to play.
	 */
	public void initializePlayer(String streamUrl) {

		mMediaPlayer = new StatefulMediaPlayer();
		mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
		try {
			mMediaPlayer.setDataSource(streamUrl);
		}
		catch (Exception e) {
			Log.e("MediaPlayerService", "error setting data source");
			mMediaPlayer.setState(MPStates.ERROR);
		}
		mMediaPlayer.setOnBufferingUpdateListener(this);
		mMediaPlayer.setOnInfoListener(this);
		mMediaPlayer.setOnPreparedListener(this);
		mMediaPlayer.prepareAsync();
	}

	@Override
	public IBinder onBind(Intent arg0) {
		return mBinder;
	}

	@Override
	public void onBufferingUpdate(MediaPlayer player, int percent) {

	}

	@Override
	public boolean onError(MediaPlayer player, int what, int extra) {
		mMediaPlayer.reset();
		mClient.onError();
		return true;
	}

	@Override
	public boolean onInfo(MediaPlayer mp, int what, int extra) {
		return false;
	}

	@Override
	public void onPrepared(MediaPlayer player) {
		mClient.onInitializePlayerSuccess();
		startMediaPlayer();

	}

	@Override
	  public int onStartCommand(Intent intent, int flags, int startId) {
	      return START_STICKY;
	  }

	/**
	 * Pauses the contained StatefulMediaPlayer
	 */
	public void pauseMediaPlayer() {
		Log.d("MediaPlayerService","pauseMediaPlayer() called");
		mMediaPlayer.pause();
		stopForeground(true);

	}

	/**
	 * Sets the client using this service.
	 * @param client The client of this service, which implements the IMediaPlayerServiceClient interface
	 */
	public void setClient(IMediaPlayerServiceClient client) {
		this.mClient = client;
	}

	 /**
	 * Starts the contained StatefulMediaPlayer and foregrounds the service to support
	 * persisted background playback.
	 */
	public void startMediaPlayer() {
		Context context = getApplicationContext();

		//set to foreground
		Notification notification = new Notification(android.R.drawable.ic_media_play, "MediaPlayerService",
		        System.currentTimeMillis());
		Intent notificationIntent = new Intent(this, MainActivity.class);
		notificationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
		PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);

		CharSequence contentTitle = "MediaPlayerService Is Playing";
		CharSequence contentText = mMediaPlayer.getStreamStation().getStationLabel();
		notification.setLatestEventInfo(context, contentTitle,
		        contentText, pendingIntent);
		startForeground(1, notification);

		Log.d("MediaPlayerService","startMediaPlayer() called");
		mMediaPlayer.start();
	}

	/**
	 * Stops the contained StatefulMediaPlayer.
	 */
	public void stopMediaPlayer() {
		stopForeground(true);
		mMediaPlayer.stop();
		mMediaPlayer.release();
	}

	public void resetMediaPlaer() {
		stopForeground(true);
		mMediaPlayer.reset();
	}

}

package com.speakingcode.android.media.mediaplayer;

/**
 * @author rootlicker http://speakingcode.com
 */
public interface IMediaPlayerServiceClient {

	/**
	 * A callback made by a MediaPlayerService onto its clients to indicate that a player is initializing.
	 * @param message A message to propagate to the client
	 */
	public void onInitializePlayerStart(String message);

	/**
	 * A callback made by a MediaPlayerService onto its clients to indicate that a player was successfully initialized.
	 */
	public void onInitializePlayerSuccess();

	/**
	 *  A callback made by a MediaPlayerService onto its clients to indicate that a player encountered an error.
	 */
	public void onError();
}

package com.speakingcode.example.android;

import android.app.Activity;
import android.app.ActivityManager;
import android.app.ActivityManager.RunningServiceInfo;
import android.app.ProgressDialog;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.content.Intent;
import android.content.ServiceConnection;
import android.net.Uri;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.Gravity;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.Spinner;
import android.widget.ToggleButton;

import com.speakingcode.example.android;
import com.speakingcode.android.media.mediaplayer.IMediaPlayerServiceClient;
import com.speakingcode.android.media.mediaplayer.MediaPlayerService;
import com.speakingcode.android.media.mediaplayer.StatefulMediaPlayer;
import com.speakingcode.android.media.mediaplayer.MediaPlayerService.MediaPlayerBinder;
import com.speakingcode.audio.media.streamStation.StreamStationSpinnerAdapter;
import com.speakingcode.audio.media.streamStation.StreamStation;

/**
 * @author rootlicker http://speakingcode.com
 */
public class MainActivity extends Activity
		implements IMediaPlayerServiceClient {
	private StatefulMediaPlayer mMediaPlayer;
	private StreamStation mSelectedStream = CONSTANTS.DEFAULT_STREAM_STATION;
	private MediaPlayerService mService;
	private boolean mBound;

	private ProgressDialog mProgressDialog;

	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		bindToService();
		mProgressDialog = new ProgressDialog(this);

		initializeButtons();
		setupStationPicker();
    }

	@Override
	public boolean onCreateOptionsMenu(Menu menu)
	{
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.main_activity_menu, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		// Handle item selection
		switch (item.getItemId())
		{
			case R.id.menuClose:
				shutdownActivity();
				return true;
			default:
				return super.onOptionsItemSelected(item);
		}
	}

	/**
	 * Binds to the instance of MediaPlayerService. If no instance of MediaPlayerService exists, it first starts
	 * a new instance of the service.
	 */
	public void bindToService() {
        Intent intent = new Intent(this, MediaPlayerService.class);

        if (MediaPlayerServiceRunning()) {
			// Bind to LocalService
	        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
		}
		else {
			startService(intent);
	        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
		}

	}

	/**
	 * Sets up the stationPicker spinner
	 */
	public void setupStationPicker() {
		Spinner stationPicker = (Spinner) findViewById(R.id.stationPicker);
	    StreamStationSpinnerAdapter adapter = new StreamStationSpinnerAdapter(
	            this, android.R.layout.simple_spinner_item);

	    //populate adapter with stations
	    for(StreamStation st : CONSTANTS.STATIONS)
	    {
	    	adapter.add(st);
	    }
	    adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
	    stationPicker.setAdapter(adapter);
	    stationPicker.setOnItemSelectedListener(new OnItemSelectedListener()
	    {

		    @Override
			public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
		    	StreamStation selectedStreamStation = (StreamStation) parent.getItemAtPosition(pos);

		    	if (selectedStreamStation != mSelectedStream)
		    	{
		    		mService.stopMediaPlayer();
		    		mSelectedStream = selectedStreamStation;
		    		mService.initializePlayer(mSelectedStream);
		    	}
		    }

		    @Override
			public void onNothingSelected(AdapterView<?> parent)
		    {
		      // Do nothing.
		    }

	    });
	}

	/**
	 * Initializes buttons by setting even handlers and listeners, etc.
	 */
	private void initializeButtons() {
		// PLAY/PAUSE BUTTON
		final ToggleButton playPauseButton = (ToggleButton) findViewById(R.id.playPauseButton);
		playPauseButton.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				if (mBound) {
					mMediaPlayer = mService.getMediaPlayer();

					//pressed pause ->pause
					if (!playPauseButton.isChecked()) {

						if (mMediaPlayer.isStarted()) {
							mService.pauseMediaPlayer();
						}

					}

					//pressed play
					else if (playPauseButton.isChecked()) {
						// STOPPED, CREATED, EMPTY, -> initialize
						if (mMediaPlayer.isStopped()
								|| mMediaPlayer.isCreated()
								|| mMediaPlayer.isEmpty())
						{
							mService.initializePlayer(mSelectedStream);
						}

						//prepared, paused -> resume play
						else if (mMediaPlayer.isPrepared()
								|| mMediaPlayer.isPaused())
						{
							mService.startMediaPlayer();
						}

					}
				}
			}

		});
	}

	/**
	 * Defines callbacks for service binding, passed to bindService()
	 */
	private ServiceConnection mConnection = new ServiceConnection() {
    	@Override
        public void onServiceConnected(ComponentName className, IBinder serviceBinder) {
    		Log.d("MainActivity","service connected");

            //bound with Service. get Service instance
            MediaPlayerBinder binder = (MediaPlayerBinder) serviceBinder;
            mService = binder.getService();

            //send this instance to the service, so it can make callbacks on this instance as a client
            mService.setClient(MainActivity.this);
            mBound = true;

            //Set play/pause button to reflect state of the service's contained player
            final ToggleButton playPauseButton = (ToggleButton) findViewById(R.id.playPauseButton);
    		playPauseButton.setChecked(mService.getMediaPlayer().isPlaying());

    		//Set station Picker to show currently set stream station
    		Spinner stationPicker = (Spinner) findViewById(R.id.stationPicker);
    		if(mService.getMediaPlayer() != null && mService.getMediaPlayer().getStreamStation() != null) {
	    		for (int i = 0; i < CONSTANTS.STATIONS.length; i++) {
	    			if (mService.getMediaPlayer().getStreamStation().equals(CONSTANTS.STATIONS[i])) {
	    				stationPicker.setSelection(i);
	    				mSelectedStream = (StreamStation) stationPicker.getItemAtPosition(i);
	    			}

	    		}
    		}

        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {
            mBound = false;
        }
    };

    /** Determines if the MediaPlayerService is already running.
     * @return true if the service is running, false otherwise.
     */
    private boolean MediaPlayerServiceRunning() {

    	ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);

    	for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
            if ("com.speakingcode.example.android.MediaPlayerService".equals(service.service.getClassName())) {
                return true;
            }
        }

        return false;
    }

    public void onInitializePlayerSuccess() {
		mProgressDialog.dismiss();

		final ToggleButton playPauseButton = (ToggleButton) findViewById(R.id.playPauseButton);
		playPauseButton.setChecked(true);
	}

    public void onInitializePlayerStart(String message) {
		mProgressDialog = ProgressDialog.show(this, "", message, true);
		mProgressDialog.getWindow().setGravity(Gravity.TOP);
		mProgressDialog.setCancelable(true);
		mProgressDialog.setOnCancelListener(new OnCancelListener() {

			@Override
			public void onCancel(DialogInterface dialogInterface) {
					MainActivity.this.mService.resetMediaPlaer();
					final ToggleButton playPauseButton = (ToggleButton) findViewById(R.id.playPauseButton);
					playPauseButton.setChecked(false);
			}

		});

	}

	@Override
	public void onError() {
			mProgressDialog.cancel();
	}

    /**
     * Closes unbinds from service, stops the service, and calls finish()
     */
    public void shutdownActivity() {

    	if (mBound) {
			mService.stopMediaPlayer();
			// Detach existing connection.
			unbindService(mConnection);
			mBound = false;
    	 }

        Intent intent = new Intent(this, MediaPlayerService.class);
    	stopService(intent);
    	finish();

    }

}

/**
 *
 */
package com.speakingcode.audio.media.streamStation;

/**
 * A class to represent Streaming media stations. Holds label, URL, and other information.
 * @author rootlicker http://speakingcode.com
 */
public class StreamStation {
	private String mStationLabel;
	private String mStationUrl;

	/**
	 * Constructs a new StreamStation object with empty label and URL
	 */
	public StreamStation() {
		this("","");
	}
	/**
	 * Constructs a new StreamStation object with specified label and URL
	 * @param stationLabel
	 * @param stationUrl
	 */
	public StreamStation(String stationLabel, String stationUrl) {
		mStationLabel = stationLabel;
		mStationUrl = stationUrl;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		StreamStation other = (StreamStation) obj;
		if (mStationLabel == null) {
			if (other.mStationLabel != null)
				return false;
		}
		else if (!mStationLabel.equals(other.mStationLabel))
			return false;
		if (mStationUrl == null) {
			if (other.mStationUrl != null)
				return false;
		}
		else if (!mStationUrl.equals(other.mStationUrl))
			return false;
		return true;
	}

	/**
	 * Gets the station's label as a String
	 * @return the station label
	 */
	public String getStationLabel() {
		return mStationLabel;
	}

	/**
	 * Gets the station's URL, as a String
	 * @return the URL of the station
	 */
	public String getStationUrl() {
		return mStationUrl;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((mStationLabel == null) ? 0 : mStationLabel.hashCode());
		result = prime * result
				+ ((mStationUrl == null) ? 0 : mStationUrl.hashCode());
		return result;
	}

	/**
	 * Sets a String as the station's label
	 * @param stationLabel the label to set
	 */
	public void setStationLabel(String stationLabel) {
		this.mStationLabel = stationLabel;
	}

	/**
	 * Set's a String as the station's URL
	 * @param stationUrl the URL of the Station
	 */
	public void setStationUrl(String mStationUrl) {
		this.mStationUrl = mStationUrl;
	}

}

package com.speakingcode.audio.media.streamStation;

import android.content.Context;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;

/**
 * @author rootlicker http://speakingcode.com
 *
 */
public class StreamStationSpinnerAdapter extends ArrayAdapter<StreamStation> {
	int mTextViewResourceId;
	Context mContext;

	public StreamStationSpinnerAdapter(Context context, int textViewResourceId) {
		super(context, textViewResourceId);
		this.mTextViewResourceId = textViewResourceId;
		mContext = context;
	}

	@Override
	public View getView(int position, View convertView, ViewGroup parent) {
		TextView tv = (TextView)(super.getView(position, convertView, parent));
		tv.setText(getItem(position).getStationLabel());
		return tv;
	}

	@Override
	public View getDropDownView(int position, View convertView, ViewGroup parent) {
		TextView tv = (TextView)(super.getDropDownView(position, convertView, parent));
		tv.setText(getItem(position).getStationLabel());
		return tv;
	}
}

package com.speakingcode.example.android;

import com.speakingcode.audio.media.streamStation.StreamStation;

/**
 * @author rootlicker http://speakingcode.com
 *
 */
public class CONSTANTS {
	public static final String DUBSTEP_HQ_URL    = "http://lemon.citrus3.com:8062";
	public static final String DUBSTEP_LQ_URL    = "http://lemon.citrus3.com:8048";
	public static final String DNB_HQ_URL        = "http://lemon.citrus3.com:8144";
	public static final String GRIME_HQ_URL      = "http://lemon.citrus3.com:8120";

	public static final String DUBSTEP_HQ_LABEL  = "FILTH.FM Dubstep Hi-Fi (192kb/s)";
	public static final String DUBSTEP_LQ_LABEL  = "FILTH.FM Dubstep Lo-Fi (96kb/s)";
	public static final String DNB_HQ_LABEL      = "FILTH.FM D&B Hi-Fi (192kb/s)";
	public static final String GRIME_HQ_LABEL    = "FILTH.FM Grime Hi-Fi (192kb/s)";
	public static final StreamStation[] STATIONS =
		{
			new StreamStation(DUBSTEP_HQ_LABEL, DUBSTEP_HQ_URL),
			new StreamStation(DUBSTEP_LQ_LABEL, DUBSTEP_LQ_URL),
			new StreamStation(DNB_HQ_LABEL, DNB_HQ_URL),
			new StreamStation(GRIME_HQ_LABEL, GRIME_HQ_URL)
		};
	public static final StreamStation DEFAULT_STREAM_STATION = STATIONS[0];
}

<?
$dirName = "./files/";
$dir = opendir($dirName);
while ($fileName = readdir($dir))
{
  echo("$filename<br>");
}
?>

This simple example, other than not being pretty, has one obvious drawback – it will list the . and .. shortcut references to the working directory its parent directory. We can wrap the echo statement in an if statement so that it is only called when $fileName does not point to . or ..

<?
$dirName = "./files/";
$dir = opendir($dirName);
while ($fileName = readdir($dir))
{
  if ( ($fileName != ".") && ($fileName != "..") )
  {
    echo ("$filename");
  }
}
?>

Now lets have a little fun.  First, instead of listing the files as plain text, we will make them hyperlinks…

<?
$dirName = "./files/";
$dir = opendir($dirName);
while ($fileName = readdir($dir))
{
  if ( ($fileName != ".") && ($fileName != "..") )
  {
    echo ("<a href=\"$dirName/$filename\">$fileName<a/>&ltbr&gt");
  }
}
?>

Hyperlinks are nifty, but rollover image swaps are a lot more fun. Assuming we have two image files named img_icon_on.png and img_icon_off.png for the onMouseOver and onMouseOut events, we want our end-result links to look something like this:

<a
	href="somefile"
	onMouseOver = "document.img_icon.src='layout_images/nav_images/img_icon_on.png'"
	onMouseOut  = "document.img_icon.src='layout_images/nav_images/img_icon_off.png'">
<img
	src="layout_images/nav_images/img_icon_off.png"
	name="img_icon"
	border="0"
/></a>

The caveat here is that we need each img tag to have a unique value assigned to the name attribute, and we need our document.<resourcename>.src portions of the onMouseOver and onMouseOut event handlers to reflect the unique img name they correspond to. We can simply append the name attribute and the DOM element names with the name of the file the link will reference. Using str_replace() we can remove any . characters from the filename so that it won’t break the output HTML:

<?
$dirName = "./files/";
$dir = opendir($dirName);
while ($fileName = readdir($dir))
{
	if (($fileName != ".") && ($fileName != ".."))
	{
		$cleanFileName = str_replace(".","",$fileName);
		echo ("
			<a
				href=\"$dirName/$fileName\"
				onMouseOver = \"document.img_icon_$cleanFileName.src='layout_images/nav_images/img_icon_on.png'\"
				onMouseOut  = \"document.img_icon_$cleanFileName.src='layout_images/nav_images/img_icon_off.png'\"
			\">
			<img
				src=\"layout_images/nav_images/img_icon_off.png\"
				name=\"img_icon_$cleanFileName\"
				border=\"0\"
			/></a>
		");
	}
}
closedir($dir);
?>

Check out the new Filth.FM Android app!

I’ve launched a new app under a company I co-operate, Skematic Design. It provides the ability to stream media from the internet radio station filth.fm They play electronic music, particularly dubstep, drum and base, and grime, so if you’re into that you’ll be in heaven.

To implement the app, I had to use the Android MediaPlayer class, actually extending it into a new class in order to manage the player’s state more easily. I also implemented a Service sub-class to provide background playback, etc. I will be adding some articles about how to do that soon. Meanwhile, check out the app at https://market.android.com/details?id=fm.filth.android.