• a title page;
• 3 test questions (the correct answer in each case is “true”); and
• a results page.

It was created using Lectora, runs in a 760 x 550 window, and sets ‘cmi.core.lesson_status’ to “passed” to indicate completion. The SCO entry point is ‘a001index.html’.

Hope it helps!

All other details – including system requirements – are the same as for Rev 1.0.

• subs.php which contains all of the code that does the parsing and analysis of the manifest file
• index.php which simply provides you with a way to run the code and display the output in a test environment

In other words, if you wanted to incorporate the code into a real system, you would only need the content of subs.php.

The system requirements for running this code are pretty simple – you just need to have PHP 5 or above (PHP 4 doesn’t support the DOM extension that I’m using to parse the XML manifest file).

To help you get started, I’ve also included the 2 sample manifest files that I’ve been using.

• A single SCO manifest file created by Captivate – [download manifest file]
• A multiple SCO manifest file that I created using Lectora – [download manifest file]

To be honest, I don’t think I’ve ever come across a multiple-SCO content package in a real application, but I do need to be able to handle it if I do stumble across it.

So let’s try the single SCO manifest file. When I run my manifest file reader, I get the following output.

This is what I’d expect from a manual analysis of the manifest file. So far, so good.

Now the multiple SCO manifest file. This is more challenging since, if you look at the manifest file itself, you can see that there are a host of linked resources, and that a number of the resources are shared by the two SCOs. So let’s give it a try – here’s what I get.

A lot more complicated but, comparing the output with the manifest file, it would certainly seem that I’ve successfully disentangled all of the dependencies, and identified the two SCOs.

All looking pretty good so far. Tomorrow I’ll post a copy of the manifest file reader code for you to download and play with.

  // array for the results
  $SCOdata = array();

  // loop through the list of items
  foreach ($itemData as $identifier => $item) {

    // find the linked resource
    $identifierref = $item['identifierref'];

    // is the linked resource a SCO? if not, skip this item
    if (strtolower($resourceData[$identifierref]['scormtype']) != 'sco') { continue; }

    // save data that we want to the output array
    $SCOdata[$identifier]['title'] = $item['title'];
    $SCOdata[$identifier]['masteryscore'] = $item['masteryscore'];
    $SCOdata[$identifier]['datafromlms'] = $item['datafromlms'];
    $SCOdata[$identifier]['href'] = $resourceData[$identifierref]['href'];
    $SCOdata[$identifier]['files'] = $resourceData[$identifierref]['files'];

  }

Next post … I’ll run some tests, and post a full copy of the code for you to download if you want to try it out for yourself.

  // array to store the results
  $itemData = array();

  // get the list of item elements
  $itemList = $xmlfile->getElementsByTagName('item');

  $i = 0;
  foreach ($itemList as $itemp) {

    // decode the item attributes and sub-elements
    $identifier = $itemList->item($i)->getAttribute('identifier');
    $itemData[$identifier]['identifierref'] = $itemList->item($i)->getAttribute('identifierref');
    $itemData[$identifier]['title'] = $itemList->item($i)->getElementsByTagName('title')->item(0)->nodeValue;
    $itemData[$identifier]['masteryscore'] = $itemList->item($i)->getElementsByTagNameNS($adlcp,'masteryscore')->item(0)->nodeValue;
    $itemData[$identifier]['datafromlms'] = $itemList->item($i)->getElementsByTagNameNS($adlcp,'datafromlms')->item(0)->nodeValue;

    $i++;

  }

This will read the item data from the manifest file into a new array called $itemData. Next step … combine the resource and item data to give me the information that I need for my “imaginary” LMS.

function resolveIMSManifestDependencies($identifier) {

  global $resourceData;

  $files = $resourceData[$identifier]['files'];

  $dependencies = $resourceData[$identifier]['dependencies'];
  if (is_array($dependencies)) {
    foreach ($dependencies as $d => $dependencyidentifier) {
      $files = array_merge($files,resolveIMSManifestDependencies($dependencyidentifier));
      unset($resourceData[$identifier]['dependencies'][$d]);
    }
    $files = array_unique($files);
  }

  return $files;

}

Here’s what I’m doing – line-by-line:

• Line 1: The function takes a resource identifier as its argument.
   
• Line 3: I’m going to process the data that I’ve stored in the $resourceData array, so I make it a global variable. I’ll have to do the same in the readIMSManifestFile() function, but more of that later.
   
• Line 5: I read the existing list of files for this resource (see line 1) into an array. I’ll be updating this as I go through the function.
   
• Line 7: I read the dependency information for this resource into an array called $dependencies.
   
• Lines 8 through 14: I loop through each of the dependencies for this resource.
   
• Line 10: This is the line that does the hard work. What I do is to merge together my existing ‘files’ array with a new ‘files’ array that I create by recursively calling the resolveIMSManifestDependencies() for each dependency (and any of its dependencies).
   
• Line 11: Since I’ve resolved this dependency (and any of its dependencies), I unset the dependency data in the $resourceData array so that I don’t process it again.
   
• Line 13: I eliminate any duplicate entries in the ‘files’ array.
   
• Line 16: I return the ‘files’ array to the calling program.
   

Now I have to modify the readIMSManifestFile() function so that it looks like this.

function readIMSManifestFile($manifestfile) {

  // PREPARATIONS

  // central array for resource data
  global $resourceData;

  // load the imsmanifest.xml file
  $xmlfile = new DomDocument;
  $xmlfile->preserveWhiteSpace = FALSE;
  $xmlfile->load($manifestfile);

  // adlcp namespace
  $manifest = $xmlfile->getElementsByTagName('manifest');
  $adlcp = $manifest->item(0)->getAttribute('xmlns:adlcp');

  // READ THE RESOURCES LIST

  // array to store the results
  $resourceData = array();

  // get the list of resource element
  $resourceList = $xmlfile->getElementsByTagName('resource');

  $r = 0;
  foreach ($resourceList as $rtemp) {

    // decode the resource attributes
    $identifier = $resourceList->item($r)->getAttribute('identifier');
    $resourceData[$identifier]['type'] = $resourceList->item($r)->getAttribute('type');
    $resourceData[$identifier]['scormtype'] = $resourceList->item($r)->getAttribute('adlcp:scormtype');
    $resourceData[$identifier]['href'] = $resourceList->item($r)->getAttribute('href');

    // list of files
    $fileList = $resourceList->item($r)->getElementsByTagName('file');

    $f = 0;
    foreach ($fileList as $ftemp) {
      $resourceData[$identifier]['files'][$f] =  $fileList->item($f)->getAttribute('href');
      $f++;
    }

    // list of dependencies
    $dependencyList = $resourceList->item($r)->getElementsByTagName('dependency');

    $d = 0;
    foreach ($dependencyList as $dtemp) {
      $resourceData[$identifier]['dependencies'][$d] =  $dependencyList->item($d)->getAttribute('identifierref');
      $d++;
    }

    $r++;

  }

  // resolve resource dependencies to create the file lists for each resource
  foreach ($resourceData as $identifier => $resource) {
    $resourceData[$identifier]['files'] = resolveIMSManifestDependencies($identifier);
  }

  // READ THE ITEMS LIST

  // PROCESS THE ITEMS LIST TO FIND SCOS

  // RETURN RESULTS

}

The changes are:

• Line 6: I make the $resourceData array – a working array where I store all of the information as I process it – global so that it’s accessible to the resolveIMSManifestDependencies() function.
   
• Lines 44 to 49: I create a list of dependencies for each resource, and save it into the $resourceData array.
   
• Lines 56 to 59: After I’ve read all of the data for the resources (the loop finishes on line 54) I loop through the list of resources again and resolve all of the dependencies by calling resolveIMSManifestDependencies() as I described above.
   

Now that I’ve read all of the resources data, I’m going to read the items data. That will be my next post.

The CAM specification defines the XML format for the <resource> tag like this.

What does this mean? That each <resource> tag contains:

So, to create a simple example, we might have a structure like this.

When I resolve all of the dependencies, the list of files that I need for the SCO identified as ‘RES01′ is as follows:

   myfile01.htm
   myfile02.gif
   data/myfile03.txt
   data/myfile04.txt
   scripts/myfile05.js
   scripts/myfile06.js
   scripts/myfile07.js
   scripts/myfile08.js

where ‘myfile01.htm’ is the entry point for the SCO. Next time … code to process the dependencies.

function readIMSManifestFile($manifestfile) {

  // PREPARATIONS

  // READ THE RESOURCES LIST

  // READ THE ITEMS LIST

  // PROCESS THE ITEMS LIST TO FIND SCOS

  // RETURN RESULTS

}

The first section is pretty straightforward since I can build on the code that I created previously.

  // PREPARATIONS

  // load the imsmanifest.xml file
  $xmlfile = new DomDocument;
  $xmlfile->preserveWhiteSpace = FALSE;
  $xmlfile->load($manifestfile);

  // adlcp namespace
  $manifest = $xmlfile->getElementsByTagName('manifest');
  $adlcp = $manifest->item(0)->getAttribute('xmlns:adlcp');

I start by loading the manifest file into a variable, and I read the XML namespace definitions that I need.

Now I move on to reading the resources list. Here’s my initial code.

  // READ THE RESOURCES LIST

  // array to store the results
  $resourceData = array();

  // get the list of resource element
  $resourceList = $xmlfile->getElementsByTagName('resource');

  $r = 0;
  foreach ($resourceList as $rtemp) {

    // decode the resource attributes
    $identifier = $resourceList->item($r)->getAttribute('identifier');
    $resourceData[$identifier]['type'] = $resourceList->item($r)->getAttribute('type');
    $resourceData[$identifier]['scormtype'] = $resourceList->item($r)->getAttribute('adlcp:scormtype');
    $resourceData[$identifier]['href'] = $resourceList->item($r)->getAttribute('href');

    // list of files
    $fileList = $resourceList->item($r)->getElementsByTagName('file');

    $f = 0;
    foreach ($fileList as $ftemp) {
      $resourceData[$identifier]['files'][$f] =  $fileList->item($f)->getAttribute('href');
      $f++;
    }

    $r++;

  }

Pretty much as I did before, but this time I’m storing the data that I read in the $resourceData array. Let’s look at the XML file that I’m reading to see if I’m capturing all of the data. Here’s a typical <resource> element.

Whoops … whereas the IMS manifest file that I was reading previously had a single resource which contained multiple files, this manifest file consists of multiple <resource> elements which appear to be linked together by <dependency> elements. So I’m going to have to take a step backward and look at the SCORM 1.2 CAM specification again in far more detail.

In Step 26 (Getting Data from the LMS), I identified that my RTE needed the following parameters to run – three of which come from the data in the imsmanifest file:

And I’m going to add a couple more that will probably be needed by a typical LMS:

1. I’m going to extract the SCO title from the manifest file as well, because I’m sure that a real LMS would need to use it in a listing screen.
    
2. The manifest file contains a list of files that constitute the resources. This would (probably) be useful for the LMS to know when importing a package so that it could extract only those files that it needs to run the SCO. This might not be quite as important right now, with disk space being so cheap, but I’ll include it anyway.

So, the data that I want from the manifest file is:

1. the SCO title
2. the mastery score set in the manifest file
3. the launch data for the SCO
4. the entry point for the SCO
5. a list of files

I’m going to create a function called readIMSManifestFile($manifestfile) which, given the path to the manifest file on disk, will return the data that I require in an array e.g.

$SCOdata = readIMSManifestFile("/data/import/123/imsmanifest.xml");

This should be easier to integrate with LMS code. To test it out, I create a short PHP/HTML program like this:

<?php 

/*

VS SCORM - CAM - index.php
Rev 2.0 - Monday, October 12, 2009
Copyright (C) 2009, Addison Robson LLC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA  02110-1301, USA.

*/

require "subs.php";
$SCOdata = readIMSManifestFile('imsmanifest.xml');

// ------------------------------------------------------------------------------------
// Process the Items List to Find SCOs
// ------------------------------------------------------------------------------------

// output table header row
$SCOListTable  = "<table cellpadding=3 cellspacing=0 border=1>\n";
$SCOListTable .= "<tr>\n";
$SCOListTable .= "\t<td valign=top align=left><b>Identifier</b></td>\n";
$SCOListTable .= "\t<td valign=top align=left><b>Title</b></td>\n";
$SCOListTable .= "\t<td valign=top align=left><b>MasteryScore</b></td>\n";
$SCOListTable .= "\t<td valign=top align=left><b>LaunchData</b></td>\n";
$SCOListTable .= "\t<td valign=top align=left><b>SCO Entry Point</b></td>\n";
$SCOListTable .= "\t<td valign=top align=left><b>Required Files</b></td>\n";
$SCOListTable .= "</tr>\n";

// loop through the list of items
foreach ($SCOdata as $identifier => $SCO) {

	// data that we want
	$SCOListTable .= "<tr>\n";
	$SCOListTable .= "\t<td valign=top align=left>".cleanVar($identifier)."</td>\n";
	$SCOListTable .= "\t<td valign=top align=left>".cleanVar($SCO['title'])."</td>\n";
	$SCOListTable .= "\t<td valign=top align=left>".cleanVar($SCO['masteryscore'])."</td>\n";
	$SCOListTable .= "\t<td valign=top align=left>".cleanVar($SCO['datafromlms'])."</td>\n";
	$SCOListTable .= "\t<td valign=top align=left>".cleanVar($SCO['href'])."</td>\n";
	$SCOListTable .= "\t<td valign=top align=left>".implode('<br>',$SCO['files'])."</td>\n";
	$SCOListTable .= "</tr>\n";

}

$SCOListTable .= "</table>\n";

// function to clean data for display
function cleanVar($value) {
  $value = (trim($value) == "") ? " " : htmlentities(trim($value));
  return $value;
}

?>
<html>
<head>
  <title></title>
  <style type="text/css">
  p,td,li,body,input,select,textarea {
    font-family: verdana, sans-serif;
    font-size: 10pt;
  }
  h1 {
    font-weight: bold;
    font-size: 12pt;
  }
  </style>
</head>
<body bgcolor="#ffffff">

<h1>SCO Data</h1>
<p><?php print $SCOListTable; ?>

<body>
</html>

This program simply requires/includes the ‘subs.php’ file that contains the functions that do the actual work, calls the readIMSManifestFile() function, and displays the resulting data in an HTML table.

One further thing to note here — you’ll see from the looping construct on lines 45 through 58 that the code is designed to handle multiple SCOs contained in the same content package. Although I’ve conducted my tests so far using a single SCO package, the SCORM 1.2 CAM specification allows there to be multiple SCOs contained within the same package.

To be quite honest, I’ve never come across a multiple SCO package in a business environment, but I do have to allow for the possibility. So I’ve created a test package consisting of 2 SCOs using the Lectora authoring tool. You can download a copy of the imsmanifest file from [here] if you’d like to follow along with the next stages.

Next post … I’m going to start writing the code for the readIMSManifestFile() function.