As just about everyone knows the iPhone is incapable of playing any sort of Flash through the mobile Safari browser and generally speaking everyone has adapted and found work arounds or changed their sites accordingly as to not require Flash for certain things.

On my personal blog about music, one of the most used plugins I have installed is the 1 Pixel Out flash MP3 player. And by the number of downloads and searches I’ve seen it’s one of the most popular ways to quickly play an mp3 inline to a blog post. It’s customizable, looks great and most of all it works perfect! That is until you try to view the post from your iPhone.

The Solution

So I hacked around the plugin and created the following patch that will detect if your viewer is using an iPhone, and if so it will serve the MP3 with a clickable “Play” image. This allows your viewer to play the mp3 straight through the iPhone! Your viewers will no longer get the no-flash error but instead get this:

Installation

Just download this zip and go to your plugins folder for Wordpress. Replace your audio-player.php file with the one provided and put the iphone_play.png image in the assets folder. That’s it!

Download

Please note that this is based on version 2.0 beta 6. And I haven’t tested all the different methods so you may see an issue here or there. Just hit me up if you have a problem and I’ll try to fix it. I’m hoping that 1 Pixel Out will integrate this into the 2.0 release officially. BTW, The user agent detection function was borrowed from WPtouch.

For you folks that want to manually do it or see what has been changed just have a look below. In the audio-player.php file you will need to make the following changes:

Add the following to line 300:

		/**
		 * Detects if the user agent is an iPhone or iPod
		 * returns true or false
		 */
		function detectAppleMobile($query = '') {
			$container = $_SERVER['HTTP_USER_AGENT'];
				$useragents = array(
				"iphone",  				 // Apple iPhone
				"ipod", 					 // Apple iPod touch
				"aspen", 				 // iPhone simulator
				"incognito", 			 // Other iPhone browser
				"webmate" 			 // Other iPhone browser
			);
			$applemobile = false;
			foreach ( $useragents as $useragent ) {
				if ( eregi( $useragent, $container ) || file_exists($devfile) ) {
					$applemobile = true;
				}
			}

			return $applemobile;
		}

after inserting that code around line 534 you will see:

			} else {
				// Not in a feed so return player widget
				$playerElementID = "audioplayer_" . $this->playerID;
				$playerCode = '<p class="audioplayer_container"><span style="display:block;padding:5px;border:1px solid #dddddd;background:#f8f8f8" id="' . $playerElementID . '">' . sprintf(__('Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version <a href="%s" title="Download Adobe Flash Player">here</a>. You also need to have JavaScript enabled in your browser.', $this->textDomain), 'http://www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash&amp;promoid=BIOW');
				$playerCode .= '</span><script type="text/javascript">';
				$playerCode .= 'AudioPlayer.embed("' . $playerElementID . '", ' . $this->php2js($playerOptions) . ');';
				$playerCode .= '</script></p>';
				return $playerCode;
			}

which needs to be replaced with:

			} else {
				if($this->detectAppleMobile()){
					$iphone_player = '';

					foreach ( explode( ",", $source) as $afilename ) {
						$afilename = trim($afilename);
						$iphone_player .= '<a href="'.$afilename.'"><img src = "'.WP_CONTENT_URL.'/plugins/audio-player/assets/iphone_play.png"></a><br />';
					}
					return $iphone_player;
				} else {
					// Not in a feed so return player widget
					$playerElementID = "audioplayer_" . $this->playerID;
					$playerCode = '<p class="audioplayer_container"><span style="display:block;padding:5px;border:1px solid #dddddd;background:#f8f8f8" id="' . $playerElementID . '">' . sprintf(__('Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version <a href="%s" title="Download Adobe Flash Player">here</a>. You also need to have JavaScript enabled in your browser.', $this->textDomain), 'http://www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash&amp;promoid=BIOW');
					$playerCode .= '</span><script type="text/javascript">';
					$playerCode .= 'AudioPlayer.embed("' . $playerElementID . '", ' . $this->php2js($playerOptions) . ');';
					$playerCode .= '</script></p>';
					return $playerCode;
				}
			}

Etags

An Etag is an HTTP response header that may be returned from your web server and is used to determine change in content on a given page. What that means is that it allows you to check a page and return either a 304 Not Modified response with no content or a 200 OK response with all the page content. Or even more practically, we can check our CSS and JS pages and the server will tell us if they’ve changed or not… and if not then use the local browser cache.

You can’t just call http://example.com/style.css and have it work. You have to have PHP check and send the proper Etag headers, which is where the Combine script comes in since it does all this for you. The script checks the Last Modified Date of each CSS/JS file and uses that in the Etag. The Etag changes when the CSS file changes, thereby telling your browser to use the new content. It’s brilliant really… and I can’t figure out why more people don’t use this method other than the VERY MINIMAL overhead (low milliseconds) that is needed to check the Etag header.

Etags and PHP

Lets look at how PHP gets involved in all this. PHP has access to a server variable called $_SERVER['HTTP_IF_NONE_MATCH'] that returns NULL if the Etags do not match. Using this variable it allows us to know if any content has changed and then act on that. Let me give you a quick example of how it works:

header('Etag: "This is the Etag header content."');

if(!isset($_SERVER['HTTP_IF_NONE_MATCH'])){
	echo "$_SERVER['HTTP_IF_NONE_MATCH'] is not set";
}else{
	// $_SERVER['HTTP_IF_NONE_MATCH'] is set so return 304
	header ("HTTP/1.0 304 Not Modified");
	header ('Content-Length: 0');
}

Houston we have a PHP problem

So if the Combine script works so great why did it stop working for us? In simple terms, PHP sort of got in the way. We started off using Combine in it’s native form… just a straight call to combine.php which served the CSS/JS. However, we recently integrated it into our framework to keep things streamlined, but I never went back to check the caching. I just figured it would still work. That was my mistake and why several months later I thought it quit working “out of the blue” when in fact it had stopped as soon as we integrated it.

The root problem is that when PHP uses sessions it modifies the cache headers because of the dynamic nature of using sessions. And wouldn’t you know it.. we use sessions (surprise surprise) and our app calls in a sessions class in the overhead portion of the app. What that means is that a session was started on each page load, including these JS and CSS calls. What happens is that when session_start() is called the server variable $_SERVER['HTTP_IF_NONE_MATCH'] is removed since PHP thinks that we don’t want to serve static content. Fun times and I now see why Rasmus dislikes frameworks due to the overhead issues.

Solution

Not being a core PHP dev I can only assume there is a real reason for how PHP handles sessions that is helpful in other instances. However to get around it I can either bypass the session_start() for JS and CSS calls (changing the overhead of the framework) or I can use the following helpful bit of code that is in PHP to allow us to change the normal behavior of sessions. Before we call session_start() we simply tell PHP that we want to set the “session cache limiter” to private by calling session_cache_limiter(’private_no_expire’).

So there you go.. a simple fix which took my half a day to track down. Hopefully I will have saved a few people the same headache when trying to use Etags and PHP sessions.

This is a PHP class that calculates the time between specified points. It can be used to determine how long your page took to generate or how long certain loops take to run. This class is very flexible because it allows you to specify any number of “marker” points in the code and then compare any of them together.

There is nothing fancy about it. I ran across a post from someone looking for something like this and claimed it was hard to find… so I figured I’d release what we have in an effort to help anyone else out there.

Current Version: 1.0

Download

Source is hosted at Google Code

Features

• PHP5+ only
• Sets the first marker automatically
• Multiple markers
• Markers are stored so they can also be used as a totalizer

How To Use It

The use is really basic. Which is good, because let’s be honest.. it’s just a timer.

A basic use:

$bm = new Benchmark();
//code here
$bm->mark('end');
echo $bm->elapsed('start', 'end') . " Seconds";
//note that 'start' was auto generated

Another use where we use other markers for something like sending an email

$bm = new Benchmark();

$bm->mark('email_start');
//email code here
$bm->mark('email_stop');

echo $bm->elapsed('email_start', 'email_stop') . " Seconds";

Using it as a totalizer

$bm = new Benchmark();

$total_time = 0;
foreach($emails as $email){
	$bm->mark('email_start');
	//email code here
	$bm->mark('email_stop');

	$total_time += $bm->elapsed('email_start', 'email_stop');
}

echo $total_time . " Seconds";

Full Documentation

Initializing the Class

$bm = new Benchmark();

• When the class is initialized a marker is auto-generated called ’start’ through the __construct method.

Public Methods

• $this->mark(string $name)
• • Sets a marker with the name that is passed in.
  • $name – (string) Name of the marker you are setting

• $this->elapsed(string $point1, string $point2 [, int $decimals = 4])
• • Gets the elapsed time between two marker points
  • $point1 – (string) Name of the first marker you are checking
  • $point2 – (string) Name of the second marker you are checking
  • $decimal – (integer, optional) Number of decimal places you want displayed in the result

Is Microtime() Bad?

Many of the “common” ways involve using the microtime() function to mark a start and end time and then doing some math to see how long it took to get from A to B. On the surface there is nothing wrong with this. In fact, we use this same method to output overall script generation times or SQL processing times to get a feel for when we write an extremely inefficient piece of code or SQL statement. A sort of alarm beacon to say “Hey, this code is WAY to slow”.

If you ask most race car drivers/owners that win consistently, they will always tell you that their success is in the details. It’s not the big things, it’s the 20 small tweaks that put them out in front their competition. And if you are developing a full blown CMS or web application and relying solely on microtime(), then you are sorely missing out on some tools you can use to take your code from bearable to fast.

Moving Beyond Microtime()

So, we obviously use microtime() to immediately see how our SQL calls and overall code is performing. If there is a slowdown ,then how do you figure out where it’s happening? Do you go through each file and add in these microtime()’s before and after each set of code? No.. that would be way to labor intensive (even though I have done it a time or two). Our answer is to use the amazing PHP extension xDebug . A few years ago we installed it as a way to trace through errors more effectively. It will overwrite PHP’s native error’s and output a stack/function trace to see how you got the error, which is extremely useful.

Another useful part of xDebug is it’s built in PHP Profiler, which is what we will use to find the slowdowns. If you turn it on, it generates a cachegrind file that can be analyzed by one of the many programs out there. We use a web based analyzer called WebGrind, which is basically just a set of PHP scripts that go through the files that xDebug generates. It will show you EVERY function that was called, how many times it was called and how long it took to run. It also shows you what files were included and how long each of those took to process. It is an amazing tool that will give you quick results on your entire code. Just this past week I reviewed a page and realized that I left some debugging code in that was eating up some serious memory.

Load Up The Server

Another tool we use is Siege, which allows the us hit a web server with a number of concurrent simulated users. Basically we stress test the code and see how fast it will respond. We set some max response time numbers that we will stay below. This helps us avoid adding too many features on one page, making it slow. Siege is a command line tool that I’ve only ever installed on a Mac (linux) but it does say it will install on Windows. To ease the installation I also use a program for Mac called DarwinPorts, but doing a regular install is not that big of a deal.

Some output from Siege.

% siege -c 5 http://akira.localhost -t30s
Transactions:               1406 hits
Availability:             100.00 %
Elapsed time:              30.47 secs
Data transferred:          14.54 MB
Response time:              0.08 secs
Transaction rate:          55.14 trans/sec
Throughput:                 0.48 MB/sec
Concurrency:                4.99
Successful transactions:    1406
Failed transactions:           0
Longest transaction:       20.61
Shortest transaction:       0.02

In this example we hit the server with 5 users for 30 seconds and the output will show us how the code performs. The 2 main numbers we look at is Response Time and Transaction Rate. As you add features and more code it will effect these numbers, especially response time since that is the measure of how long it takes to send the first bits of data. If we can optimize our code to come in under our max response time, then that give us room to add more features without worrying about the app feeling sluggish.

Is It Overkill

Maybe. If you’re throwing together some quick scripts, then who cares? But if you are developing a full application that you want people to use then you might begin to care. We can not be lazy developers. Loading in a bunch of overhead to speed up development at the expense of our users is lazy coding. The only way to determine if we went too far in feature bloat on a page or using to much overhead is to benchmark and review our code. Anyone can read the PHP manual and create a website, but to be a great programmer you have to know where you are writing bad code and work to improve it.

Doing more and more CSS/XHTML development brought to light that sometimes there might be a need to wrap an image with a span or div element to produce a dropshadow effect or to position it how you want. Chris and I were having a discussion about this and he came up with an idea of adding some Javascript “helpers” to speed up the coding of our CSS/XHTML.

Let me give you an example to help clarify what I’m talking about. Let’s say we have an image and we need that image to have a dropshadow. To do this we need to wrap it in a span tag so that our CSS works properly. So everywhere we want a dropshadowed image we would have to have something like this:

<span><img src = "image.png" /></span>

But we could easily write a javascript function (in our case we use jQuery) to have it auto-wrap all img elements having the class “dropshadow” with span tags.

$('img.dropshadow').wrap("<span></span>");

This simplifies and speeds up the HTML we have to write, because all we have to put into our templates is an img tag. In this case it doesn’t save a ton of time, but when you think about it in terms of styling forms with images or changing buttons to use different image types or styles you really begin to save a lot of time. And the best part is that you can keep things semantically correct. The markup doesn’t need span tags to keep the semantic meaning of having an image. The spans are there just to add the detail of the dropshadow in.

I’ve seem this methodology used in many plugins, so we’re not coming up with any revolutionary. But the point of this post is to try to push developers that have the convenience of using javascript, to use it to speed up their development. In an upcoming post we’re going to be sharing our use of a helper that simplifies how we style many different buttons in Mosaic. Hopefully that will show a real world example where it is literally saving us hours of work, over the course of building the app, everywhere we have need of a button.

So now that we can think of dates and times as a true date (e.g. 2009/04/27) all the way from PHP to MySQL, using a true date/time column type, it really speeds thing up. However, in the native DateTime class constants there is not a MySQL format for inserting the date object directly into a database. I realized that all I needed to do was create my own constant that aligns with the prebuilt ones.

Here is the only code you need

define('DATE_MYSQL', "Y/m/d H:i:s");

Here it is in context.

define('DATE_MYSQL', "Y/m/d H:i:s");

$dateTime = new DateTime("now");
echo $dateTime->format(DATE_MYSQL);

You’ll notice I use the same format as the other date constants like DATE_RSS to be consistent. Also note that with this same code you can set up any type of format that you can use on your site or in your code.

The company

A year or so ago we scaled back our client based work to set our focus on an idea for a web application that we really believe in and believe can help solve alot problems (and create some form of world peace). That change also brought a new opportunity for Phil to work for a great design company called Springbox in Austin as an Art Directors, but continuing to head up the creative direction here at Intereactive. Over the past year our interests have taken different paths and as of this April, we all came to terms with the fact that Phil will no longer be here at Intereactive. Major bummer. We left on probably the best terms ever, so I can’t complain at all. In fact I believe trying to plod ahead when people aren’t “into it” really hurts you more than anything. If you are a fan of Phil’s work please check him out over at philcoffman.com.

Mootools to Jquery

On a more technical note, the aftermath of our time at the SXSW conference left us with a major change to our JS framework. Chris and I went in to a Javascript panel where John Resig (creator of jQuery) was speaking and we both left with a very uneasy feeling about using our current framework Mootools. Let me make one thing very clear… We still love Mootools. And honestly, it’s very hard to pinpoint our exact reasons for switching. But chiefly among them was that we felt that while Mootools is a very strong framework, jQuery has a much brighter future. There seems to be much more involvement in releasing new code and more innovative ways in solving some of the problems. We’ve currently re-written all our code within Mosaic using jQuery and it’s much shorter (for whatever that is worth). There are definitely shortcomings in the animation side of things, but all in all we are very happy with the move.

Focusing on the basics – a PHP framework

We are mainly a PHP shop that has been writing code since before most people knew what a framework really was, so when it came time to start writing an application we pretty much already had our own lean, mean framework that we were already familiar with. The last few months we’ve taken that framework and really oiled the gears and shined up the fenders and made it into a full blown MVC framework using syntax that we are familiar with. With Chris’s insistance, we’ve broken it out of the application, made it it’s own project, and given it life through the name “Akira”. The name Akira comes from the name of the Commander of the Black Lion (the core leader) of Voltron… so in turn, our Akira is also the core of what makes an overall project work and function properly. Well that and we’re just geeks at heart. It’s something we can quickly plop onto a blank slate and have an idea fleshed out in less than a day. Just yesterday I coded up an entire home finance manager for my personal use in less than 5-6 hours using the framework.

And before we get the request… no, we won’t be releasing it to the public. It’s honestly no better than CodeIgniter or Kohana… we are just familiar with the methods and syntax of our own stuff so it’s faster for us to write. If you aren’t using a framework.. Use one! I suggest Kohana.

Errata

So in summary… we lost a badass designer (very sad), switched to an awesome JS framework (very happy), and spent way too much time developing Akira (very very happy). There are countless other things that have sidetracked us over the past year such as redefining our goals, having kids, taking vacations and going to conferences. But now I believe we have the focus we need and the tools to get there. It’s amazing how change can be so frustrating, but once you are through it, it is so freeing. We’ll be reworking the Intereactive site soon to be more inline with who we are now and also be showing off some features of Mosaic in the blog in the next few weeks or so.

MultiSlide is a Mootools class that will group multiple slide effects together and allow you to slide them all in or out at one time. MultiSlide will also allow you to retain individual control over each slide and it contains several callback events for easier integration into your UI.

Current Version: 1.0

Download

Source is hosted at GitHub

Features

• Built on Mootools 1.2 and weighs in at 4kb (uncompressed)
• Opening or closing of multiple slides with one button
• Retains individual control over each separate slide
• Uses customizable CSS classes for hooks, so that no additional markup is needed
• Several callback events for custom UI controls
• Transition speed and type are configurable

Demo

• Basic Example
• Example with a few more options

How To Use It

The basic structure should closely follow the following structure when building multiple slides. You can have as many of the “ms_container’s” as you need and all are controlled by the top two elements. Consider each of the following sections as an HTML element with the class name as shown. Please note that these are just the default class names and can be replaced with your own custom ones to reduce markup.

The standard way to initialize MultiSlide is to call the class and pass in the CSS class name of the element that wraps each slide. In this case it would be:
var multislide = new multislide('ms_container');
You can also call the “expand all” and “collapse all” methods from your javascript by calling:
multilside.expand_all();
multilside.collapse_all();

Please read the documentation below and look at the demos to see how to further customize the MultiSlide class.

Documentation

Syntax

new multislide(container_class [, options]);

Arguments

• container_class – (mixed) A string of the CSS class name that wraps each slide instance
• options – (object, optional) key/value set of options

Options

• slide_duration – (number) duration (in milliseconds) of the slide; defaults to 300
• slide_transition – (string) transition that the slide should use; defaults to ’sine:in:out’
• class_expand_all – (string) CSS class name that is applied to the element that will expand all the slides; defaults to ‘expand_all’
• class_collapse_all – (string) CSS class name that is applied to the element that will collapse all the slides; defaults to ‘collapse_all’
• class_toggler – (string) CSS class name that is applied to the element that will toggle the individual slide; defaults to ‘ms_toggler’
• class_expander – (string) CSS class name that is applied to the element that will be the slide; defaults to ‘ms_expander’

Methods

• expand_all – Used to expand all the slides at one time
• collapse_all – Used to collapse all the slides at one time

Custom Events

• onExpand – Fired anytime a single slide in the group is exapnded by it’s toggler. Passes the toggler element that was clicked back to the event to be able to make UI changes.
• onCollapse – Fired anytime a single slide in the group is collapsed by it’s toggler. Passes the toggler element that was clicked back to the event to be able to make UI changes.
• onExpand_all – Fired anytime the “exapand all” runs
• onCollapse_all – Fired anytime the “collapse all” runs

]]> http://blueprint.intereactive.net/multislide-for-mootools/feed/ 6 http://blueprint.intereactive.net/mootools-dom-selector-tips/ http://blueprint.intereactive.net/mootools-dom-selector-tips/#comments Sun, 15 Feb 2009 17:23:59 +0000 Ryan http://blueprint.intereactive.net/?p=130 In most javascript frameworks, one of the most powerful tools they offer is the DOM selector function. It’s commonly known in Mootools and Prototype as the double-dollar ($$) and in jQuery it’s just a single-dollar ($). It allows us to search and find elements in the DOM and return them as an array.

For instance, $$(”p”) will return an array of all the elements in the DOM with the p tag. A more powerful example would be $$(”.post”), where you get a returned array of elements that have the class “post”. Add in some Mootools slickness and we can really make it powerful by use of the Selectors such as $$(”.post:last-child”) to select the last element that has the class “post”.

As I’ve been active in the Mootools forums and various blogs and such, I’ve seen lots of people that are new to Mootools (or JS in general), not quite understand what to do with this function. One of the key things to remember when dealing with this function is that it returns the elements in a way that you can apply all the Mootools element methods.

Here are some examples of how I often see this function overcomplicated

//Common way that is used
$$('.status').each(function(el){
	el.set('html','Success');
});

//Shorter way to write this
$$('.status').set('html','Success');

Or a more complex example where chaining together methods can be used. As Aaron points out in the comments chaining methods causes the selector to run multiple times, which with a large result set will hinder performance.

//Common way that is used
$$('.status').each(function(el){
	el.set('html','Success');
	el.highlight();
});

//Shorter way to write this
$$('.status').set('html','Success').highlight();

Mootools also allows you to apply Tween or Morph directly on an element such as element.tween(’color’, ‘#009900′) or element.morph(’.class_name’). This allows us to also use tween and morph via the double-dollar($$) like:

//Using Tween to change the text color in last p tag in the DOM
$$('p:last-child').tween('color', '#009900');

//Using Morph to morph all p tags in the DOM to a class named "large"
$$('p').morph('.large');

There are definitely times when we should use the “each” array itterator to do several things to each value, but more often than not I see it overused which really complicated the code. And that has a chain reaction that will further make it harder for new users to understand how to use the framework. Mootools has gone to great lengths to allow us to simplify our code and we should be using this shorter code whenever possible.


]]> http://blueprint.intereactive.net/mootools-dom-selector-tips/feed/ 5 http://blueprint.intereactive.net/bypassing-protected-twitter-feeds-using-php/ http://blueprint.intereactive.net/bypassing-protected-twitter-feeds-using-php/#comments Wed, 31 Dec 2008 15:59:35 +0000 Ryan http://blueprint.intereactive.net/?p=123 I had a little personal project where I needed to combine my wife’s and my Twitter feed into one common feed. This was so we could display it on our blog and it would show in realtime what we were doing. Not a problem using Yahoo Pipes since our accounts are unprotected and open to the public. I created a simple pipe to combine the feeds and sort by date.

This past week I had another personal project where we have a large music festival with lots of people that will be twittering while the event is going on. Many of them have their account protected (for whatever reason) and short of asking them to unprotect it for the week of the festival, there is no easy way to get access to their feed. I couldn’t even get access to it for a few days because once you open your feed to the public anyone can see all your history.

What I needed was a way to grab their twitter feed only during the festival so I put my brain in overdrive and shortly after came up with a pretty elegant way of doing it. I had remembered using a script called Snoopy that is a PHP class that simulates a web browser. I dug through the Twitter API and found the “friends_timeline” call, which is basically a feed of all my friend’s tweets (what you see on twitter.com/home). I put the 2 together and had the core of a script that would let me login to Twitter and pull the tweets for everyone I follow.

There are two ways to go from here. You could create a dedicated Twitter account and follow just the people you want to display on the overall feed. Or you can create an array of usernames in your code that is used to filter only the ones you want in the overall feed. In my final code I choose to go with the later for simplicity.

Here is the core of what I wrote to pull in the feed via XML

require_once('snoopy.class.php');
$snoopy = new Snoopy;
$snoopy->agent = 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)';
$snoopy->user = 'your_twitter_username';
$snoopy->pass = 'your_twitter_password';
$snoopy->fetch('http://twitter.com/statuses/friends_timeline.xml');

// Make sure we connected to the API
if (strpos($snoopy->response_code, '200')) {
	// Use PHP's SimpleXML functions
	$xml = simplexml_load_string($snoopy->results);
	foreach($xml->status as $status) {
		// Do your code here using the format:
		// $status->id
		// $status->user->screen_name
		// etc...
	}
}

There are a few things to note:
1) The main thing is that if someone has their Twitter marked as “protected”, it is that way for a reason. Be SURE you have their permission to pull their tweets only during a set time of your event or whatever you are doing.
2) The Twitter API will only display the latest 20 tweets. To get around this I created a PHP file using the above code and I run it on a Cron Job every 1 minute, dumping the results in a database table. Then I pull from that DB table when I display the feed. Here is the complete file that I use (I added the Snoopy class so it would be self contained): twitter_grab_cron.zip


]]> http://blueprint.intereactive.net/bypassing-protected-twitter-feeds-using-php/feed/ 4