In addition, I should probably make sure that no API calls are processed before the API session has been initialized. This isn’t as much of a problem as long as the SCO has been well-written since, according to the SCORM standard, LMSInitialize should always be the first API function called by the SCO/course.

So, building on the work I did in Step 48, I’m going to introduce a second JavaScript variable – flagInitialized – into api.php:

var flagFinished = false;
var flagInitiaized = false;

There are now five API calls to be changed so that they test for appropriate values of flagInitialized and flagFinished.

1. LMSInitialize

This API call can only be executed if the session HASN’T already been initialized, and the session HASN’T been closed. So I modify my code like this:

1
2
3
4
5
6
7
8
9
10
11
12

function LMSInitialize(dummyString) {
 
  // already initialized or already finished
  if ((flagInitialized) || (flagFinished)) { return "false"; }
 
  // set initialization flag
  flagInitialized = true;
 
  // return success value
  return "true";
 
}

If either flagInitialized or flagFinished is set to ‘true’, execution of the function will be aborted. If it proceeds, line 7 sets the ‘flagInitialized’ variable so that other API calls know that the session is initialized.

2. LMSFinish

This API call can only be executed if the session HAS been initialized but HAS NOT yet been closed. So the code looks like this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

function LMSFinish(dummyString) {
 
  // not initialized or already finished
  if ((! flagInitialized) || (flagFinished)) { return "false"; }
 
  ...
  ...
 
  // set finish flag
  flagFinished = true;
 
  // return to calling program
  return "true";
 
}

Very similar to LMSInitialize except that I only allow the code to run if flagInitialized is set to ‘true’, and flagFinished is set to ‘false’. If the function executes correctly, line 10 sets flagFinished to ‘true’ so that there can be no further communication between the SCO/course and the LMS.

3. LMSGetValue, LMSSetValue and LMSCommit

Finally, I need to add the following code to each of these three API calls to ensure that the code is only executed if the session HAS been initialized, but HAS NOT been closed.

1
2

  // not initialized or already finished
  if ((! flagInitialized) || (flagFinished)) { return "false"; }

And that’s it.

$rawscore = readElement('cmi.score.raw');

It should read:

$rawscore = readElement('cmi.core.score.raw');

I’ll incorporate this fix in a new release of the RTE once I’ve made a few other improvements.

If you want a very simple test case, you can use this content package. It’s a single SCO consisting of:

• 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!

NOTES

3. As before, this is a technology demonstrator – not production-standard code – so please don’t blame me if you find bugs! You can let me know what you find using the contact form on this blog, or by posting a comment.

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

It works as I’d hoped. It’s difficult to gauge any speed improvements because of intentional (i.e. developer-programmed) time delays in the Flash file(s) while they’re displaying. The display time is also affected by server-side caching of files. But it would be fair to say that it seems slightly more responsive, especially when displaying the application simulation exercise. And, when I look at the database contents after closing the window, this is what I see:

Closing the window manually (rather than using an exit button in the course) has called LMSFinish() and triggered the finish.php code correctly, and things look as I’d expected.

Now I try the problem course that I mentioned in Step 43. I can’t show you the course because it’s client-specific, but the speed improvement seems to be significant. Once again, it’s difficult to get an exact figure, but I’d say that page loads (including SCORM API calls by the SCO) were at least 2 to 3 times faster – perhaps even more.

Although not definitive, I think that’s fairly reassuring. Next time, I’ll post a copy of the code for you to play around with, and you can tell me if you see similar results.

In Rev 1 of the code, the course/SCO call to LMSInitialize() caused an AJAX request to be sent to the server where a script called initialize.php was executed. The one thing that this doesn’t do is to transfer all of the data element values from the database into the local cache. In theory, I could simply use one or more additional AJAX calls to transfer the data from the server to the local cache. But I think there’s a better way.

I’m going to start by modifying my api.php code by adding the following lines of code.

1
2
3
4
5
6
7

//  read database login information and connect
require "config.php";
dbConnect();
 
// initialize data elements in the database if they're not already set, and
// dynamically create the javascript code to initialize the local cache
$initializeCache = initializeSCO();

Lines 2 and 3 load the database configuration information, and connect to the database. Then, line 7 calls a function in subs.php that will initialize the SCO. The value returned from the function is stored in a PHP variable called $initializeCache – I’ll talk about what it’s used for later.

Here’s my new initializeSCO() function in subs.php.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

function initializeSCO() {
 
  global $link;
  global $SCOInstanceID;
 
  // has the SCO previously been initialized?
  $result = mysql_query("select count(VarName) from scormvars where (SCOInstanceID=$SCOInstanceID)",$link);
  list($count) = mysql_fetch_row($result);
 
  // not yet initialized - initialize all elements
  if (! $count) {
 
    // elements that tell the SCO which other elements are supported by this API
    initializeElement('cmi.core._children','student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,exit,session_time');
    initializeElement('cmi.core.score._children','raw');
 
    // student information
    initializeElement('cmi.core.student_name',getFromLMS('cmi.core.student_name'));
    initializeElement('cmi.core.student_id',getFromLMS('cmi.core.student_id'));
 
    // test score
    initializeElement('cmi.core.score.raw','');
    initializeElement('adlcp:masteryscore',getFromLMS('adlcp:masteryscore'));
 
    // SCO launch and suspend data
    initializeElement('cmi.launch_data',getFromLMS('cmi.launch_data'));
    initializeElement('cmi.suspend_data','');
 
    // progress and completion tracking
    initializeElement('cmi.core.lesson_location','');
    initializeElement('cmi.core.credit','credit');
    initializeElement('cmi.core.lesson_status','not attempted');
    initializeElement('cmi.core.entry','ab initio');
    initializeElement('cmi.core.exit','');
 
    // seat time
    initializeElement('cmi.core.total_time','0000:00:00');
    initializeElement('cmi.core.session_time','');
 
  }
 
  // new session so clear pre-existing session time
  writeElement('cmi.core.session_time','');
 
  // create the javascript code that will be used to set up the javascript cache, 
  $initializeCache = "var cache = new Object();\n";
 
  $result = mysql_query("select VarName,VarValue from scormvars where (SCOInstanceID=$SCOInstanceID)",$link);
  while (list($varname,$varvalue) = mysql_fetch_row($result)) {
 
    // make the value safe by escaping quotes and special characters
    $jvarvalue = addslashes($varvalue);
 
    // javascript to set the initial cache value
    $initializeCache .= "cache['$varname'] = '$jvarvalue';\n";
 
  }
 
  // return javascript for cache initialization to the calling program
  return $initializeCache;
 
}

Here’s how it breaks down – line-by-line:

• Lines 7 and 8 – I’m testing for whether this SCO has already been initialized in my LMS database table by counting the number of data elements corresponding to this SCOInstanceID.
   
• Lines 11 through 40 – These lines are only executed if the SCO hasn’t yet been initialized. They’re pretty much the same as were in the initialize.php code in Rev 1, and they set the initial database values for all of the SCORM data elements that I’m supporting.
   
• Line 43 – I clear any previous setting for the SCO session time data element.
   
• Lines 46 through 57 – Here, I’m going to create a set of JavaScript statements that will initialize the local cache. Now, obviously, I can’t do this using directly from the subs.php code since that’s being executed on the server. But, I’ll save them into a PHP variable and return them to the calling program where they can be executed on the client side.
   

So, when called, the initializeSCO() function sets up the initial database entries (if required) and then created the JavaScript initialization code. So, in api.php, I add the following.

<?php print $initializeCache; ?>

which, will result in the student’s browser seeing something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

var cache = new Object();
cache['cmi.core._children'] = 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,exit,session_time';
cache['cmi.core.score._children'] = 'raw';
cache['cmi.core.student_name'] = 'Addison, Steve';
cache['cmi.core.student_id'] = '007';
cache['cmi.core.score.raw'] = '';
cache['adlcp:masteryscore'] = '0';
cache['cmi.launch_data'] = '';
cache['cmi.suspend_data'] = '';
cache['cmi.core.lesson_location'] = '';
cache['cmi.core.credit'] = 'credit';
cache['cmi.core.lesson_status'] = 'not attempted';
cache['cmi.core.entry'] = 'ab initio';
cache['cmi.core.exit'] = '';
cache['cmi.core.total_time'] = '0000:00:00';
cache['cmi.core.session_time'] = '';

And, if you refer back to one of my earlier posts, you’ll see that this creates the local cache as a JavaScript object containing the initial values from the database.

Finally, I can get rid of the LMSInitialize() code, and modified form of api.php now looks like this.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204

<?php 
 
/* 
 
VS SCORM - JavaScript SCORM 1.2 RTE API
Rev 4.0 - Friday, November 27, 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.
 
*/
 
//  essential functions
require "subs.php";
 
// input data
$SCOInstanceID = $_REQUEST['SCOInstanceID'] * 1;
 
//  read database login information and connect
require "config.php";
dbConnect();
 
// initialize data elements in the database if they're not already set, and
// dynamically create the javascript code to initialize the local cache
$initializeCache = initializeSCO();
 
?>
<html>
<head>
<title></title>
<script language="javascript">
 
// ------------------------------------------
//   Status Flags
// ------------------------------------------
var flagFinished = false;
 
// ------------------------------------------
//   SCO Data Cache - Initialization
// ------------------------------------------
<?php print $initializeCache; ?>
 
// ------------------------------------------
//   SCORM RTE Functions - Initialization
// ------------------------------------------
function LMSInitialize(dummyString) {
  return "true";
}
 
// ------------------------------------------
//   SCORM RTE Functions - Getting and Setting Values
// ------------------------------------------
function LMSGetValue(varname) {
  return cache[varname];
}
 
function LMSSetValue(varname,varvalue) {
  cache[varname] = varvalue;
  return "true";
}
 
// ------------------------------------------
//   SCORM RTE Functions - Saving the Cache to the Database
// ------------------------------------------
function LMSCommit(dummyString) {
 
  // create request object
  var req = createRequest();
 
  // code to prevent caching
  var d = new Date();
 
  // set up request parameters - uses POST method
  req.open('POST','commit.php',false);
 
  // create a POST-formatted list of cached data elements 
  // include only SCO-writeable data elements
  var params = 'SCOInstanceID=<?php print $SCOInstanceID; ?>&code='+d.getTime();
  params += "&data[cmi.core.lesson_location]="+urlencode(cache['cmi.core.lesson_location']);
  params += "&data[cmi.core.lesson_status]="+urlencode(cache['cmi.core.lesson_status']);
  params += "&data[cmi.core.exit]="+urlencode(cache['cmi.core.exit']);
  params += "&data[cmi.core.session_time]="+urlencode(cache['cmi.core.session_time']);
  params += "&data[cmi.core.score.raw]="+urlencode(cache['cmi.core.score.raw']);
  params += "&data[cmi.suspend_data]="+urlencode(cache['cmi.suspend_data']);
 
  // request headers
  req.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
  req.setRequestHeader("Content-length", params.length);
  req.setRequestHeader("Connection", "close");
 
  // submit to the server for processing
  req.send(params);
 
  // process returned data - error condition
  if (req.status != 200) {
    alert('Problem with AJAX Request in LMSCommit()');
    return "false";
  }
 
  // process returned data - OK
  else {
    return "true";
  }
 
}
 
// ------------------------------------------
//   SCORM RTE Functions - Closing The Session
// ------------------------------------------
function LMSFinish(dummyString) {
 
  // already finished - prevent repeat call
  if (flagFinished) {
    return "true";
  }
 
  // commit cached values to the database
  LMSCommit('');
 
  // create request object
  var req = createRequest();
 
  // code to prevent caching
  var d = new Date();
 
  // set up request parameters - uses GET method
  req.open('GET','finish.php?SCOInstanceID=<?php print $SCOInstanceID; ?>&code='+d.getTime(),false);
 
  // submit to the server for processing
  req.send(null);
 
  // process returned data - error condition
  if (req.status != 200) {
    alert('Problem with AJAX Request in LMSFinish()');
    return "";
  }
 
  // set finish flag
  flagFinished = true;
 
  // return to calling program
  return "true";
 
}
 
// ------------------------------------------
//   SCORM RTE Functions - Error Handling
// ------------------------------------------
function LMSGetLastError() {
  return 0;
}
 
function LMSGetDiagnostic(errorCode) {
  return "diagnostic string";
}
 
function LMSGetErrorString(errorCode) {
  return "error string";
}
 
// ------------------------------------------
//   AJAX Request Handling
// ------------------------------------------
function createRequest() {
 
  ...
  ...
  ...
 
}
 
// ------------------------------------------
//   URL Encoding
// ------------------------------------------
function urlencode( str ) {
 
  ...
  ...
  ...
 
}
 
</script>
 
</head>
<body>
 
&nbsp;
 
</body>
</html>

Note that I’ve omitted the code for the createRequest() and urlencode() functions for clarity.

Next step – give it a trial run and see what happens.

Wrinkle #1: LMSCommit() Not Called Before LMSFinish()

In Rev 1 of the code, all API calls were carried out immediately they were invoked which meant that the LMS database was always up-to-date with the information being set by the course. Therefore, when the course called LMSFinish(), I knew that I was operating on up-to-date values for each of the data elements.

In Rev 2 of the code, values of the data elements are cached in the students’ browsers until the course developer chooses to invoke the LMSCommit() API call. A smart course developer will do this relatively often – certainly after any major change in the values of the data elements. However, I can’t rely on all courses being developed by smart developers. So I need to add a call to LMSCommit() to the top of my LMSFinish() API code to ensure that it’s going to be operating on the final set of data values:

function LMSFinish(dummyString) {
 
  // commit cached values to the database
  LMSCommit('');
 
  ...

That’s straightforward enough.

Wrinkle #2: Course Window May Be Closed Unexpectedly

While it would be nice to think that students will always use the navigation buttons that the developer provides in his/her course, you and I know that this isn’t going to happen. Students will sometimes choose to close the course window by clicking on the ‘x’ at the top of the window.

OK – technically, this wrinkle existed in Rev 1 of the code as well, but I just didn’t worry about it as much since I knew that the database would always have an up-to-date copy of the data element values, and thus the course would be able to re-start fairly easily. To handle this with my caching version of the API, I have to make sure that the course invokes LMSFinish() when the browser window is closed for any reason.

In theory, the course developer should try to handle this. As Claude Ostyn says on page 9 of his SCORM Cookbook (with my emphasis):

To ensure that LMSFinish will be called even if the SCO is unloaded expectedly, a properly initialized SCO should be coded to call LMSFinish at the following times, and under the following circumstances:

• When it no longer needs to communicate with the runtime service. For example, when the user clicks a “submit” button at the end of a test and the user will not be allowed to change responses, a SCO may upload the results of the test with LMSSetValue, then call LMSFinish.
   
• If LMSFinish has not been called successfully yet, when an onbeforeunload browser event is processed (typically, this will only happen if the browser is Internet Explorer).
   
• If LMSFinish has not been called successfully yet, when an onunload browser event is processed.
   

However, I can’t rely on course developers always being responsible. So I can help myself out by modifying my rte.php code like this:

1
2
3
4
5
6
7
8
9
10

<html>
<head>
  <title>VS SCORM</title>
</head>
<frameset frameborder="0" framespacing="0" border="0" rows="50,*" cols="*" 
            onbeforeunload="API.LMSFinish('');" onunload="API.LMSFinish('');">
  <frame src="api.php?SCOInstanceID=<?php print $SCOInstanceID; ?>" name="API" noresize>
  <frame src="../course/index.html" name="course">
</frameset>
</html>

In the frameset tag, you’ll see that I’ve added an onunload() action, and an onbeforeunload() action. In each case, the action calls LMSFinish() to try to make sure that everything is nicely wrapped-up should the student close the course/SCO window in some way other than using the course/SCO navigation buttons.

Why both onbeforeunload() and onunload()? It’s difficult to find a definitive statement on the Internet but, according to what I’ve read, it seems that onbeforeunload() is a Microsoft extension that’s supported in Internet Explorer, and in recent versions of other browsers (Safari, FireFox). However, Opera doesn’t support it (please let me know if I’m wrong), and I’m not sure about Chrome. So, by using both onbeforeunload() and onunload(), I have a pretty good chance of one or both of them being triggered by the frameset closing.

Wrinkle #3: Multiple Calls to LMSFinish()

The solution to wrinkle #2 causes another wrinkle. It’s now possible that LMSFinish() could be called more than once. The SCORM 1.2 RTE specification is clear about this – LMSFinish() should be called once, and only once, at the end of the course/SCO session.

To handle this, I’m going to introduce a JavaScript variable into api.php to act as a ‘flag’:

var flagFinished = false;

Initially set to ‘false’, I’m going to make sure that, when called, LMSFinish() …

1. Tests to see if flagFinished is set to ‘true’ and, if so, aborts processing.
2. If flagFinished is set to ‘false’, processes the data element values as usual.
3. Sets flagFinished to ‘true’ before exiting.

In the next section, I’ll show you how I do that.

So, What Does The Code Look Like?

Even including all of the changes I’ve outlined above, the basic form of the LMSFinish() API function in api.php is little changed from my previous version. It looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

function LMSFinish(dummyString) {
 
  // already finished - prevent repeat call
  if (flagFinished) {
    return "true";
  }
 
  // commit cached values to the database
  LMSCommit('');
 
  // create request object
  var req = createRequest();
 
  // code to prevent caching
  var d = new Date();
 
  // set up request parameters - uses GET method
  req.open('GET','finish.php?SCOInstanceID=<?php print $SCOInstanceID; ?>&code='+d.getTime(),false);
 
  // submit to the server for processing
  req.send(null);
 
  // process returned data - error condition
  if (req.status != 200) {
    alert('Problem with AJAX Request in LMSFinish()');
    return "";
  }
 
  // set finish flag
  flagFinished = true;
 
  // return to calling program
  return "true";
 
}

The differences from the Rev 1 code are as follows:

• Lines 4 through 6 – I’m going to check the JavaScript variable ‘flagFinshed’ in api.php to see if LMSFinish() has previously been called. If so, it aborts processing.
   
• Line 9 – Calls LMSCommit() to make sure that all data element values have been transferred to the LMS database before I invoke the finish.php code, and the course closes.
   
• Line 30 – I set the flag to show that I’ve successfully finished the LMSFinish() process, and that communication between the SCO and the LMS is now closed.
   

That was a fairly complex topic with a relatively simple resolution. Next time, I’ll look at the other end of the course/SCO session – initialization.

Here’s the JavaScript code that will be included in the api.php file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

function LMSCommit(dummyString) {
 
  // create request object
  var req = createRequest();
 
  // code to prevent caching
  var d = new Date();
 
  // set up request parameters - uses POST method
  req.open('POST','commit.php',false);
 
  // create a POST-formatted list of cached data elements 
  // include only SCO-writeable data elements
  var params = 'SCOInstanceID=<?php print $SCOInstanceID; ?>&code='+d.getTime();
  params += "&data[cmi.core.lesson_location]="+urlencode(cache['cmi.core.lesson_location']);
  params += "&data[cmi.core.lesson_status]="+urlencode(cache['cmi.core.lesson_status']);
  params += "&data[cmi.core.exit]="+urlencode(cache['cmi.core.exit']);
  params += "&data[cmi.core.session_time]="+urlencode(cache['cmi.core.session_time']);
  params += "&data[cmi.core.score.raw]="+urlencode(cache['cmi.core.score.raw']);
  params += "&data[cmi.suspend_data]="+urlencode(cache['cmi.suspend_data']);
 
  // request headers
  req.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
  req.setRequestHeader("Content-length", params.length);
  req.setRequestHeader("Connection", "close");
 
  // submit to the server for processing
  req.send(params);
 
  // process returned data - error condition
  if (req.status != 200) {
    alert('Problem with AJAX Request in LMSCommit()');
    return "false";
  }
 
  // process returned data - OK
  else {
    return "true";
  }
 
}

Line-by-line:

• Line 4 – Sets up an AJAX request object.
   
• Line 7 – Creates a date object that I’ll use to make sure that the server treats this as a new request, and doesn’t cache it.
   
• Line 10 – I’m going to send this AJAX request to a new file called commit.php, and it’s going to include POST data rather than GET data because I don’t know whether or not it would be small enough to pass as GET data. As before, the third parameter is set to ‘false’ so the request is treated as synchronous – the JavaScript will wait for it to return a response.
   
• Lines 14 through 20 – I’m creating a JavaScript variable called ‘params’ which will hold (temporarily) all of the data that I’m going to transfer.
   
  • The first two variables – SCOInstanceID and code – should be familiar from my previous work.
     
  • The subsequent variables are transferring the data from the cache to commit.php as an associative array where the keys are the data element names. Note that I’m only transferring a subset of the data from the cache – these are the data elements that are SCO-writeable – see this post if you need a reminder.

   

• Lines 23 through 25 – I set up the request headers that will be sent to the LMS server to tell it that POST data is being submitted.
   
• Line 28 – I submit the request to the server along with the data to be stored in the LMS database.
   

Now to put together the code that will handle things at the server end of things. This is going to be a new file called commit.php.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

<?php 
 
/*
 
VS SCORM - commit.php
Rev 1.0 - Thursday, November 19, 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.
 
*/
 
//  essential functions
require "subs.php";
 
//  read database login information and connect
require "config.php";
dbConnect();
 
// read SCOInstanceID
$SCOInstanceID = $_REQUEST['SCOInstanceID'] * 1;
$data = $_REQUEST['data'];
if (! is_array($data)) { $data = array($data); }
 
// iterate through the data elements
foreach ($data as $varname => $varvalue) {
 
  // save data to the 'scormvars' table
  writeElement($varname,$varvalue);
 
}
 
// return value to the calling program
print "true";
 
?>

Again, line-by-line:

• Lines 34 to 36 – Read the data that’s been passed to the script. Note that, in line 36, I make sure that the ‘data’ variable is handled as an array – probably superfluous, but may as well make sure!
   
• Lines 39 through 44 – I loop through the $data array and update the values stored in the LMS database using the writeElement() function that’s in subs.php.
   

And that’s it. Next time – LMSFinish() and some of the issues that arise from the student closing the window unexpectedly.

function LMSGetValue(varname) {
  return cache[varname];
}
 
function LMSSetValue(varname,varvalue) {
  cache[varname] = varvalue;
  return "true";
}

Much less stressful than I’d anticipated. Next time, something a little more complicated – handling LMSCommit().