Wanting to use it for my own photos, I couldn’t wait to get started. Since I already have a bunch of my own photos hosted using Gallery2, I decided to see if I could hook up an RSS feed and get it running quickly. Unfortunately the default installation of the RSS plugin with Gallery2 didn’t support media rss. My plugin version was a bit outdated so first I had to upgrade it.

Being new to Gallery2 development, I had to take a little bit and familiarize myself with the code. The code structure is very well done and was pretty easy to start seeing what needed to be done. I wanted to stick with the existing convention and not break anything unintentionally, so I made copies where needed and was careful about what I changed in shared files.

The code is located mostly under the /modules directory. The /core sub-directory contains the Gallery core files. What we’re interested in lies in /rss. Makes sense right? First thing I did was to make a examine the existing usage. When viewing an album via a browser, the RSS feed link shows that the resource is accessed via g2_view=rss.SimpleRender. So I made a copy of /rss/SimpleRender.inc to /rss/MediaRss.inc. My original version of the RSS plugin did not have any support for the media rss format, but the latest update does. That helps make my task a LOT easier, but there is still more to do.

1. Add the ‘useMedia’ parameter and the page variable to the params array.
   
   $params['useCloud'] = false;
   $params['useMedia'] = true;

   $params['page'] = GalleryUtilities::getRequestVariables('page');
$ret = $this->continueRender($params);


Next, we need to examine the other classes that are used to support the feed generation. Looking under the /classes directory (/modules/rss/classes), we see two that catch the eye immediately. RssHelper.class and RssGenerator.class.

RssHelper.class generates the SQL which is used to find items to show in the feed. One of the main things missing here is the ability to paginate results. So let’s add it! In the getFeed function, find the function call for fetchAlbumTree and make the following change:
From
RssHelper::fetchAlbumTree(
$entity->getId(),
$param['count'],
$newOnly,
$param['feedType'] != 'album',
$param['feedType'] == 'photosRecursive' ? $param['photosRecursiveLimit'] : 0,
$param['feedType'] == 'photosRandomRecursive');

To
RssHelper::fetchAlbumTree(
$entity->getId(),
array('count' => $param['count'], 'offset' => $param['offset']),
$newOnly,
$param['feedType'] != 'album',
$param['feedType'] == 'photosRecursive' ? $param['photosRecursiveLimit'] : 0,
$param['feedType'] == 'photosRandomRecursive');


We’ll put in the calculations for the offset in a bit. First we worry about how to make sure it’s used. In the ‘fetchAlbumTree’ function, we need to check the $limit parameter and use it to set the offset.

if (isset($limit)) {
$params['limit'] = array('count' => $limit);
}

Becomes

if (isset($limit)) {
if (is_array($limit)) $params['limit'] = $limit;
else $params['limit'] = array('count' => $limit);
}
}

The offset parameter is now used in the $gallery->search call. Now, I thought I was all done, but when reviewing the response, I noticed the media:thumbnail url was set the same as the description. This resulted in Cooliris not being able to pull in the thumbnails for the wall. The bug is in the RssHelper.class code, function addPhotoOrAlbum. Here is the change:

$itemSettings['thumbnail']['url'] = $url;
SHOULD BE
$itemSettings['thumbnail']['url'] = $imageUrl;


RssGenerator.class does just that. Depending on the version of RSS and whether you are ‘useMedia’, it generates the correct response XML document for feed readers. There are a few changes here.

1. Add a ‘default’ statement to function generate() so we use 2.0 by default
   
case '2.0':
default:
return $this->generate200();
break;

2. Because we want pagination of our results, for the infinite wall experience in cooliris, we need to determine the next and previous feed URLs. We will use an Apache rewrite rule for a pretty URL, so here’s the code to generate the links based on the current URL.
   

        $platform =& $gallery->getPlatform();
         $lf = $platform->getLineEnding();
   
         if (isset($this->_properties['useMedia']) && $this->_properties['useMedia'] == 1) {
           $generator = $gallery->getUrlGenerator();
           //GalleryUtilities::putRequestVariable('page', 4);
           $current = $generator->getCurrentRequestUri();
           $matches = array();
           if (preg_match("#media(\d*).rss$#", $current, $matches)) {
             $curPage = $matches[1];
             if (intval($curPage) < 1) {
               $curPage = 1;
             }
             $nextPage = $generator->makeUrl($current);
             $nextPage = preg_replace("#media\d*.rss#", "media" . ($curPage + 1) . ".rss", $nextPage);
             if ($curPage > 1) {
               $prevPage = $generator->makeUrl($current);
               $prevPage = preg_replace("#media\d*.rss#", "media" . ($curPage - 1) . ".rss", $prevPage);
             }
           }
   
           $multiPage = <<<MULTIPAGE
       <atom:link rel="previous" href="$prevPage" />
       <atom:link rel="next" href="$nextPage" />
   MULTIPAGE;
         }

3. Since we’re using ATOM, we need to tell setup the XML namespace in our response.
   
if (isset($this->_properties['useMedia']) && $this->_properties['useMedia'] == 1) {
$data = '';
}

4. Finally, we add the links into the response right after the link tag.
   
' ' . $this->_properties['link'] . '' . $lf .
$multiPage . $lf .
'' .


5. All this, but we’re not handling the pages correctly during the request. What we’re missing is the ability to control where the slice happens. Open up Render.inc in the /modules/rss/ directory and find where $generator->sliceItems($count); is being called. We have already changed RssHelper::getFeed to handle the SQL offset, all we need is to set the ‘offset’ variable.
   

       if (isset($params['page']) && $params['page'] > 1) {
           $start = ($params['page'] - 1) * $count;
       } else {
           $start = 0;
       }
       $params['count'] = $count;
       $params['offset'] = $start;
   
       $generator = new RssGenerator();
   

Pretty SEO URLs

We want to present easy to understand URLs to any spider. Instead of /main.php?g2_view=rss.MediaRss&g2_itemId=xxxx….., let’s do something like the /v/album1/subAlbum/ style URL. Of course, the Cooliris embed wall only seems to like urls that end in .rss which means we MUST do this step.

If we take a look at the existing rewrite rule for Paths, we can just modify their scheme to fit our needs.

RewriteCond %{THE_REQUEST} /gallery/v/([^?]+)(\?.|\ .)
RewriteCond %{REQUEST_URI} !/gallery/main\.php$
RewriteRule . /gallery/main.php?g2_path=%1 [QSA,L]

Now it look simply like everything after /gallery/v/ and before query parameters is dumped into a g2_path variable. We need the same thing except we must also check the page that we are on. I settled on a URL like:
/gallery/m/album_path_info/media2.rss
Here, we use the same path method that View does and we have additional page information after media. Our rewrite rule would look something like:

RewriteCond %{REQUEST_URI} /gallery/m/([^?]+)/media(\d*).rss
RewriteRule . /gallery/main.php?g2_view=rss.MediaRss&g2_path=%1&g2_page=%2 [QSA,L]


That’s pretty much it. We can now access any of our albums with a media.rss feed that allows pagination and viewing in Cooliris’s Embed Wall.

For future enhancements, it should be possible to hook up the album navigation thru Javascript and have a seamless interface suitable for a Gallery2 Theme.

Maybe I’ll do that for fun next weekend.
-Huey