Install and Configuration Guide for Icodeon SCORM Player Version 2.00 (Java Edition)

Icodeon Ltd
St Johns Innovation Centre
Cowley Road
Cambridge
Cambs
CB4 0WS
United Kingdom
+44 (0)870 950 6582
<sales@icodeon.com>

Install and Configuration Guide for Icodeon SCORM Player Version 2.00 (Java Edition)
February 2008
Table of Contents
List of Tables
Table of Contents
Welcome and thank you for choosing the Icodeon SCORM Player Version 2 (Java Edition). The Icodeon SCORM Player Version 2 (Java Edition) is a full SCORM run time environment designed to be easily intgerated into new or exisiting learning management systems.

SCORM 2004 games based learning running in the Icodeon SCORM Player
The Player supports full latest SCORM 2004 Sequencing and Navigation specification to enable advanced adaptive web based learning.
The Icodeon SCORM Player is designed around a set of standards based web services that exchange XML documents with a SCORM run time environment in an Internet Browser.

The player runs in the browser and exchnages XML documents with web services
Table of Contents

The Icodeon SCORM Player Version 2 (Java Edition) is distributed as a .zip file
The Icodeon SCORM Player Version 2 (Java Edition) is distributed as a .zip file. Icodeon provide a username and password to download the zip file from the Icodeon website. Once the file is downloaded and unzipped, the following directory structure is seen:
[PARENT DIRECTORY]/config/
[PARENT DIRECTORY]/docs/
[PARENT DIRECTORY]/javadoc/api
[PARENT DIRECTORY]/javadoc/impl
[PARENT DIRECTORY]/jmeter
[PARENT DIRECTORY]/legal/
[PARENT DIRECTORY]/maven/src
[PARENT DIRECTORY]/sql/
[PARENT DIRECTORY]/tomcat/
[PARENT DIRECTORY]/war/
[PARENT DIRECTORY]/webapps/player2
The contents of these directories and their files are
described in greater detail elsewhere. Summary descriptions are: config: some example database configuration files that can be used as a starting point for deployment specific configuration.
docs: the Install and Configuration Guide (this document).
javadoc/api: the Java documentation for API, Exceptions, Constants and Interfaces defined in compiled code in the library called icodeon-player-2.jar.
javadoc/impl: the Java documentation for classes that implement the Icodeon Player APIs and Interfaces. The documentation is for the compiled code in the library called icodeon-player-plugins-2.jar.
jmeter: test scripts for the JMeter Performance Test tool.
legal: licenses for 3rd party libraries used in the Icodeon SCORM Player Version 2 (Java Edition) and the Icodeon Software Evaluation License.
maven/src: the Java source code files for classes that implement the Icodeon Player APIs and Interfaces. This source code is for the compiled code in the library called icodeon-player-plugins-2.jar and is intended as exemplars for vendors developing thier own plug-in implementations.
sql: files containing the SQL required to set up the database tables for a number of popular databases.
tomcat: scipts and utilities for managing deployment to Apache Tomcat, a popular open source servlet container/application server.
war: compressed web application archive (WAR) file for deployment to a servlet container/application server.
webapps/player2: uncompressed web application archive for the Icodeon SCORM Player Version 2 (Java Edition).
The Icodeon SCORM Player (Java Edition) is distributed with a 30-day evaluation license that can be found at the following location:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/classes/player2.license
When the 30 day evaluation period has expired, a commercial license
can be obtained from Icodeon and copied to this location to replace the evaluation license.
The state of the license can be browsed when the following URL is used:
[WEB APP ROOT]/about.do
Table of Contents
The following SCORM versions are supported:
SCORM 1.2
SCORM 2004 3rd Edition including SCORM run time environment, and all SCORM sequencing and navigation behaviour.
Summary conformance logs for SCORM 2004 3rd Editon conformance are available for inspection.
The Icodeon SCORM Player Version 2 (Java Edition) will display and sequence IMS Content Packages. The Player determines automatically at run time the content type. The correct adapters and behaviours are automatically loaded and no special set up is required by the host LMS.
The Icodeon SCORM Player Version 2 (Java Edition) has been tested on the following browser and operating system combinations:
| Operating System | Browser | Comment |
|---|---|---|
| Windows 2000 | Internet Explorer 6 | OK |
| Windows XP | Internet Explorer 6 | OK |
| Windows XP | FireFox 1.5 | OK |
| Windows VISTA | Internet Explorer 7 | OK |
| Windows VISTA | FireFox 2 | OK |
| Windows VISTA | Opera 9 | OK |
| Windows VISTA | Safari 3 | OK |
| Mac OS X | Safari 3 | OK |
| Mac OS X | FireFox 2 | OK |
| Mac OS X | Omniweb 5.5 | OK |
| Mac OS X | Camino 1.5 | OK |
| Mac OS X | Opera 9 | OK |
Table 3.1. Browser and Operating System Combinations for Icodeon Player
The Icodeon SCORM Player Version 2 (Java Edition) uses the Hibernate system as a software layer between the application and a relational database. All databases supported by Hibernate are therefore supported by the Player. The software distribution comes with SQL and example configuration files for the following databases:
MySQL
Microsoft SQL Server 2000
Firebird
The Icodeon SCORM Player Version 2 (Java Edition) is compiled against Java 1.4, and should run with versions of Java greater than this. The presentation components of the Player, JavaServer Pages (.jsp), are built against the following specifications:
JavaServer Pages 2.0 specification
Servlet 2.4 specification
The Icodeon SCORM Player is designed to be deployed to servlet containers that implement the Servlet 2.4 and JavaServer Pages 2.0 specifications. The application has bee tested on the following containers:
Apache Tomcat Version 5.5
Caucho Resin Version 3.024
Jetty Version 5.1
The Icodeon SCORM Player Version 2 (Java Edition) will be adding support for the IMS Tools Interoperability Specification in future versions. The specification enables a secure web services integration between the Icodeon Player and a host learning management system (LMS).
The Icodeon SCORM Player Version 2 (Java Edition) reports SCORM tracking data as an XML binding according to the schema for Content Object Comunciation Data Model, published as the IEEE 1484.11.3 standard. When a SCORM object is running in the Player, any tracking data passed from the SCORM object to the Player web services is sent as a SOAP message with an IEEE 1484.11.3 schema valid XML document instance.
Table of Contents
The Icodeon SCORM Player Version 2 (Java Edition) web application files are distributed within the directory at:
[PARENT DIRECTORY]/webapps/player2
that includes a configuration file called:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/web.xml
The default deployment is to specify a "context" (typically called
"player2", which will be the assumed context/web application name in this document) in a
servlet container that points to the /webapps/player2 directory. For a fast initial
deployment, XML file based persistence can be chosen to verify application install. This
avoids the extra overhead of setting up database persistence. The steps below are for the
Tomcat 5.5 servlet container. Other servlet containers will be very similar: The web application war file, player2.war can be added to the servlet container Alternatively, an XML context fragement with the fully qualified path to the root web application directory can be added below the /conf/Catalina/[hostname] directory in Tomcat: <Context path="/player2" docBase="C:\path\to\root\...\player2" debug="0" privileged="true"> </Context> A sample fragment ready to be edited and copied below /conf/Catalina/[hostname] in Tomcat is provided with this distribution at:
[PARENT DIRECTORY]/tomcat/conf/Catalina/localhost/player2.xml
Using the file system, navigate to the web application configuration file called "web.xml". Edit the "web.xml" configuration file using an XML editor. Edit the entries for persistence factory classes. These classes are "plug-ins" that enable different persistence strategies to be supported. For XML file based persistence, set the following values:
<context-param>
<param-name>CMIPersistenceFactory</param-name>
<param-value>com.icodeon.services.cmi.dao.xml.PersistenceFactoryImpl</param-value>
</context-param>
<context-param>
<param-name>SSPersistenceFactory</param-name>
<param-value>com.icodeon.services.ss.dao.xml.PersistenceFactoryImpl</param-value>
</context-param>
NOTE: XML based persistence is not intended for production
deployments. XML file based persistance is aimed at two scenarios: (1) for content
developers who need to run the player locally without the overhead of a database, and
(2) for evaluators who wish to quickly install the Player without working through the
set up of a database.Restart the Tomcat application server.
Using a browser, open the index.html page at:
http://localhost:8080/player2/index.html
A welcome screen is shown. The welcome screen is not part of the Icodeon SCORM Player Version 2 (Java Edition) application, but acts as an example page. The page contains minimal mark-up and script to show the Player can be launched from a static HTML page.
The Icodeon SCORM Player Version 2 (Java Edition) is based on a SCORM run time environment in the browser exchanging XML documents with SOAP based web services on the server. It is important to check that the web servcies are deployed correctly before attempting to launch the browser base client-side code.

Web services exchange XML documents with a SCORM run time environment
Check the web service for the SCORM Computer Managed Instruction (CMI) data model is available at:
http://localhost:8080/player2/services/CmiService?wsdl
Check the web service for the SCORM Sequencing and Navigation is available at:
http://localhost:8080/player2/services/SequencingService?wsdl
The Icodeon SCORM Player is distributed with some example SCORM Package Interchange Files (PIF) and IMS Content Packages (CP). These are provided in the default location:
[PARENT DIRECTORY]/webapps/player2/CourseImports/
Check that these packages can be launched in the Icodeon SCORM
Player by clicking one of the course links on the static HTML index.html page. For a successful deployment, the course will be running in a new window.

SCORM 1.2 Detective [ [full size] ]
When the application is configured for XML based persistece, state is written to the file system as XML files under the directory:
[PARENT DIRECTORY]/webapps/player2/WEB-INF
Deployists may need to ensure that read/write permissions are
available for this directory. SCORM tracking model data from is written to the
directory:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/CMIRun
SCORM sequencing state data from is written to the directory:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/SSRun
Production deployment essentially follows the same steps as the default deployment described above, with two important differences. Firstly, production deployments will want to set up relational database persistence: XML file based peristence is not intended for production deployments. Secondly, there are a nummer of small changes that need to be made to promote a secure deployment. The steps are:
Follow the steps for the default deployment. Deployists may want to change the name of the context/web application to something meaningful for a particular context.
Follow the steps for the database configuration.
Follow the steps for the user interface configuration.
Follow the steps for the course content management configuration .
Ensure that any exceptions created by the software do not provide rich error details for users. Make the following edits to the log4j.properties configuration file which is found at:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/classes/log4j.properties
By setting the logging of application action classes to "ERROR"
will turn off rich error details. By setting the logging of application action classes
to "DEBUG" will turn on rich error details.
# The RTE Actions that respond to requests
log4j.logger.com.icodeon.rte.actions=ERROR,Console,A1
Ensure that other log levels are set to ERROR and that a log location is chosen:
...
# The Sequencing Service
log4j.logger.com.icodeon.services.ss=ERROR,Console,A1
# The CMI Data Model Service
log4j.logger.com.icodeon.services.cmi=ERROR,Console,A1
...
log4j.appender.A1.file=C:/../logs/icodeon_player.log
...
Ensure that no client side logging is exposed to users:
<context-param>
<param-name>ajaxLogLevel</param-name>
<param-value>NONE</param-value>
</context-param>
...
<context-param>
<param-name>isDebugAjax</param-name>
<param-value>false</param-value>
</context-param>
Remove support and training files that came with the distribution that should not be exposed to users:
[PARENT DIRECTORY]/webapps/player2/index.html
[PARENT DIRECTORY]/webapps/player2/LMSFrameset.html
[PARENT DIRECTORY]/webapps/player2/LMSFrameset_header.html
[PARENT DIRECTORY]/webapps/player2/LMSFrameset_main.html
[PARENT DIRECTORY]/webapps/player2/LMSFrameset_menu.html
[PARENT DIRECTORY]/webapps/player2/LMSDatabase.jsp
[PARENT DIRECTORY]/webapps/player2/LMSPackages.jsp
The application is now configured for production use.
Often the servlet container (Apache Tomcat, Resin) will be configured to run behind other servers, and sometimes also bound using a connector between a front end server and the servlet container. The Icodeon Player builds absolute URLs for reading in content from the SCORM package and for sending SOAP messages from AJAX client classes to web services. The Player provides configuration to ensure that the absolute URLs built by the Player are consistent with proxy servers and connected front end server. Configuration is managed by the parameter:
<context-param>
<param-name>requestUrlType</param-name>
<param-value>server</param-value>
</context-param>
This parameter is made available to manage deployments where there may be proxy servers or connectors that hand off requests to the servlet container in which the web application is deployed. URLs for service end points are determined according to the following algorithm to give maximum flexibility in deployments especially where proxy servers or connectors may be configured.
If an absolute URL is specified (such an LCMSEndPoint value in web.xml), the specified absolute value is always used to construct the URL.
If a relative URL is specificed in the web.xml, this is converted to an absolute URL or left as a relative URL according to the value of the requestUrlType parameter, which can have a value of "server", "remote", "local", "client" or "relative".
Parameter value "server" means that the host name of the server to which the request was sent is used to construct absolute URLs.
Parameter value "remote" means that the fully qualified name for the container or the last proxy that sent the request is used to construct absolute URLs.
Parameter value "local" means that the fully qualified name for the container that sent the request is used to construct absolute URLs.
Parameter value "client" means that a fully qualified name reconstructed from the URL for the container request is used to construct absolute URLs.
Parameter value "relative" means that a realtive path is used to construct realtive URLs (not recommended).
Table of Contents
The Icodeon SCORM Player Version 2 (Java Edition) uses the Hibernate library to manage persistence of instances of business object classes to a relational database. The Player therefore supports all databases supported by Hibernate. In the Icodeon software distribution, SQL scripts and example configuration files are included for MySQL, Firebird and Microsoft SQL Server 2000.
The software distribution comes with SQL for generating required database tables. Each table may be prefixed with three characters that are used for the Icodeon namespace ("ICN") to distinguish Player tables from any exisiting host LMS tables. The SQL files can be found in the directory:
[PARENT DIRECTORY]/sql/
On first use the SQL files may need to be edited. For
example, lines starting with:
alter table ATTEMPT_PROGRESS_INFO drop foreign key FKE551D07EEC46D115;
...
drop table if exists ATTEMPT_PROGRESS_INFO;
may cause errors to be reported because the tables have not
yet been created. Once the database tables have been created, the un-edited SQL files should
be used to re-generate a the database tables. The database schema inherits semantics from the specifications used within the SCORM 2004 specification. In particular, the table names and field names are based on the following specifications: IMS Simple Sequencing IMS Content Packaging Computer Managed Instruction (CMI) Data Model
For further details of the database schema, and examples of report queries, please see the accompanying document schema.html
The Icodeon SCORM Player Version 2 (Java Edition) supports an extensible architecture for persistence: it is possible to "plug-in" different persistence strategies. The distribution comes with two strategies:
Persistence to the file system as XML
Persistence to a relational database through the Hibernate layer

Default and custom plug-in persistence strategies for the CMI tracking service
To enable the default "plug-in" for persistence to a relational database through the Hibernate layer, it is necessary to ensure the correct factory classes are specified. Using the file system, navigate to the "web.xml" configuration file, and then oprn using an XML editor. Edit the entries for persistence factory classes. These classes are "plug-ins" that enable different persistence strategies to be supported. For NHibernate based persistence, set the following values:
<context-param>
<param-name>CMIPersistenceFactory</param-name>
<param-value>com.icodeon.services.cmi.dao.hibernate.PersistenceFactoryImpl</param-value>
</context-param>
<context-param>
<param-name>SSPersistenceFactory</param-name>
<param-value>com.icodeon.services.ss.dao.hibernate.PersistenceFactoryImpl</param-value>
</context-param>
The Hibernate system uses XML configuration files (typically with file extension "myfilename.cfg.xml") to pass various parameter values (such as connection strings) to the applications. The software distribution comes with example Hibernate configuration files in a directory located:
[PARENT DIRECTORY]/config/
Deployists will need to copy and then edit one of these
example files for the specific parameter values (such as connection string, driver) of the
local deployment environment. The remaining steps for database configuration are to map the
location of the Hibernate configuration file to a parameter value of a parameter named
"domainID" and to provide the "domainID" parameter value in the launch parameters of the
Icodeon Player. The steps are: Copy and then edit one of the example Hibernate configuration files for the specific parameter values (such as connection string, driver) of the local deployment environment and database type:
<hibernate-configuration>
<session-factory>
...
<!-- Database specific properties -->
<property name="connection.url">jdbc:mysql://localhost/player_db1</property>
<property name="connection.username">root</property>
<property name="connection.password">admin</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
...
</session-factory>
</hibernate-configuration>
There will need to be one Hibernate configuration file
for each database instance that the application needs to support. For example, if an
vendor is providing SCORM services to three customers, then the vendor may decide to
use a different database for each customer. Choose a value for the parameter "doaminID". The value can be any alphanumeriuc string, for example "customer1".
Rename the configuration file with the value of the "domainID" parameter as a namespace prefix to the existing file name(which is "hibernate.cfg.xml"). The table below illustrates some "domainID" parameter values and the corresponding hibernate configuration file names:
Copy the cofiuration file to the "classes" directort within the web application:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/classes/mysql1.hibernate.cfg.xml
The value of the "domainID" parameter needs to be added to the launch parameters of the Icodeon Player. For example, if an HTML form is being used to launch the Player window, the "domainID" parameter and value would be added as a hidden form field:
<form method="post">
...
<input type="hidden" name="domainID" value="mysql1"/>
...
</form>
Table of Contents
SCORM content is distributed as compressed .zip file known as a Package Interchange File (PIF). A host learning management system will typically provide some facility for uploading and unzipping these files to a network location. It is the responsibility of the host learning management system to provide the Player with a unique identifer, the "courseID" parameter value, that can be resolved to the location of the unzipped PIF.
The details of exactly how the "courseID" is resolved to the network location of an unzipped PIF is implementation specific. The software is provided with the default implementation and source code. Vendors are free to write their own implementation as a "plug-in" for a vendor specific strategy for resolving the "courseID" parameter value to the the location of the unzipped PIF.
The default implementation relies on a simple strategy of:
Specifing path for a root directory for all unzipped PIF files. This directory is specified in the web.config configuration file, and can be a relative or absolute URL:
<context-param>
<param-name>LCMSEndPoint</param-name>
<param-value>CourseImports</param-value>
</context-param>
The example above specifies a directory relative to
the application directory. For an default deployment with a context/web application
name "player2" all unzipped PIF files would be found at:
http://localhost:8080/player2/CourseImports
If an ansolute URL had been specified: URL:
<context-param>
<param-name>LCMSEndPoint</param-name>
<param-value>http://localhost/content/scorm</param-value>
</context-param>
all unzipped PIF files would be found below the
"scorm" web site directory. Specifying that the "courseID" parameter value is the same as the directory name of the unzipped PIF file. The Player then builds a URL to read in the imsmanifest.xml file give the location of the root directory that contains all unzipped PIF files, and the specific directory name of the directory contained the unzipped PIF file itself.
The code that implements this strategy is in a class called "BasicAuthenticationResolver" and compiled into a library called "icodeon-player-plugins-2.jar". The class is specified by a fully qualified class name in the web.xml configuration file.
<context-param>
<description>Plug in resolver for getting resources from an LCMS</description>
<param-name>LCMSPlugin</param-name>
<param-value>com.icodeon.rte.plugins.BasicAuthenticationResolver</param-value>
</context-param>
The source code for this default implementation is found in:
[PARENT DIRECTORY]/maven/src/main/java/com/icodeon/rte/plugins
Icodeon customers are licensed to re-use this code as a
basis for their own implementation to "plug-in" as a replacement for the default
implementation. The process of writing a "plug-in" implementation to relace the default implementation is as follows:
Design a strategy that can be implemented in Java code that resolves a given "courseID" to the unqiue network location of the unzipped PIF file.
Code the strategy as an "PlugIn_Resolver" implemention class, that implemenents the interface:
com.icodeon.rte.plugins.PlugIn_Resolver
The distribtuion comes with three example
implemenations to guide new implemenation by vendors:
[PARENT DIRECTORY]/sql/maven/src/.../plugins/BasicAuthenticationResolver.java
[PARENT DIRECTORY]/sql/maven/src/.../plugins/FileSystemResolver.java
[PARENT DIRECTORY]/sql/maven/src/.../plugins/MockResolver.java
The new implementation should be compiled into a Java Archive File (.jar) and added to the /lib directory of the web appliction. The resolver implementation can then be specified in the "web.xml" configuration file: <context-param> <description>Plug in resolver for getting resources from an LCMS</description> <param-name>LCMSPlugin</param-name> <param-value>com.vendor.rte.plugins.MyNewResolverImplementation</param-value> </context-param>
There is a well known issue in SCORM implementations known as the "SCORM Cross-Domain Scripting Issue" that is a variant of the browser "Single Origin" security policy: that scripts from a web page from one domain may not invoke functions of a script on a web page of another domain.
The issue arrises in SCORM implementations as SCORM specifies that a host run time environment (such as the Icodeon SCORM Player Version 2 (Java Edition)) and content objects must establish a communication session through Java Script function calls.
There is ongoing discussion within the community of SCORM implementers concerning this cross-domain scripting issue. Icodeon recommends placing both the Icodeon Player and the Course Content within the same network domain to be the most successful strategy.
The Icodeon SCORM Player Version 2 (Java Edition) has been tested with content produced by the following SCORM authoring and packaging tools:
Table of Contents
User interface configuration (internationalization, UI devices and skins) is managed through a set of parameter name/value pairs, and full details are given below. The name/value pairs may be configured at different levels of "priority": for example a parameter name/value pair as part of a URL query string in request scope has a higher priority than the same parameter name/value pair configured for application scope. The rule is: request scope settings ALWAYS override application scope.
The levels of priority, from lowest to highest are:
Application scope configuration. The parameter value is determined from configuration in the "web.xml" file:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/web.xml
Application scope configuration. The parameter value is determined from configuration from System properties or the "player.properties" file. Values set in the "player.properties" file, override values set in "web.xml":
[PARENT DIRECTORY]/webapps/player2/WEB-INF/classes/player.properties
Request scope configuration. Any application scope configuration is overriden. The value is determined from URL parameters of the type "parameterName=parameterValue" or form field values in the launch request:
http://www.myhost.com/player2/skins/main.do?courseID=abc&...¶meterName=parameterValue&...
So in summary, parameter values can be set in "web.xml" (application scope), System properties/"player.properties" (application scope, overides web.xml) or request scope (overrides application scope).
The Icodeon SCORM Player Version 2 (Java Edition) supports an extensible system for user interface language. Property files (.properties) can be added in the directory location:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/classes/com/icodeon/rte/properties
By default the Icodeon SCORM Player Version 2 (Java
Edition) supports the following languages in the table below. The language system is
extensible, so vendors can request additions to the languages supported, and the list is
continually updated by Icodeon, so please check back to see if a required language is
supported.| Culture Code | Language, Country |
|---|---|
| da-DK | Danish, Denmark |
| de-DE | German, Germany |
| en-GB | English, UK |
| en-US | English, US |
| es-ES | Spanish, Spain |
| fi-FI | Finnish, Finland |
| fr-FR | French, France |
| nb-NO | Norwiegen Bokmål, Norway |
| nl-NL | Dutch, Netherlands |
| pl-PL | Polish, Poland |
| sv-SV | Swedish, Sweden |
Table 7.1. Default Languages Supported by the Icodeon Player Version 2
No configuration and HTTP headers ignored. The default culture is en-US.
No configuration and HTTP not headers ignored. The culture is determined from HTTP headers sent from the browser.
Application scope configuration. HTTP headers ignored. The culture is determined from configuration in "web.xml".
Application scope configuration. HTTP headers ignored. The culture is determined from configuration in "player.properties".
Request scope configuration. HTTP headers ignored. Any application scope configuration is overriden. The culture is determined from URL parameters of the type "culture=xx_XX" or form field values in the launch request.
The following section describes the configuration of each of the five levels of priority in more detail, with specific configuration details.
No configuration and HTTP headers ignored.. Open the file called "struts-config.xml" in an XML editor. The file is located at:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/struts-config.xml
Edit the "locale" attibute of the "controller" element to
"false":
<controller pagePattern="$M$P" inputForward="true" locale="false">
<set-property property="contentType" value="text/html;charset=UTF-8"/>
</controller>
Remove all other references to the "culture" parameter from
"web.xml", "player.properties", URL launch requests or launch forms:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/web.xml
[PARENT DIRECTORY]/webapps/player2/WEB-INF/classes/player.properties
The default culture is en-US for all users. No configuration and HTTP not headers ignored. Repeat the steps for the configuration in Step 1, but set edit the "locale" attibute of the "controller" element to "true":
<controller pagePattern="$M$P" inputForward="true" locale="true">
<set-property property="contentType" value="text/html;charset=UTF-8"/>
</controller>
The culture is now set depending on values set by
the browser in the HTTP headers. Application scope configuration. HTTP headers ignored.The culture is determined from configuration in "web.xml". Repeat the steps for the configuration in Step 1, but set edit the "culture" context configuration parameter within the "web.xml" configuration file:
<context-param>
<param-name>culture</param-name>
<param-value>fr_FR</param-value>
</context-param>
The culture is now set depending on values in the
"web.xml" file. Application scope configuration. HTTP headers ignored. The culture is determined from configuration in "player.properties". Repeat the steps for the configuration in Step 3, but set edit the "culture" property within the "player.properties" configuration file:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/classes/player.properties
The culture is now set depending on values in the "player.properties" file and
overrides settings in the "web.xml" file. Request scope configuration. HTTP headers ignored. Any application scope configuration is overriden. The culture is determined from URL parameters of the type "culture=xx_XX" or form field values in the launch request. Repeat the steps for the configuration in Step 3 or 4, but add the "culture=xx_XX" as a URL parameter name/value pair or form field:
http://www.myhost.com/player2/skins/main.do?courseID=abc&...&culture=xx_XX&...
The culture is now set depending on values in launch request.
The URL parameters override any settings in "player.properties" file and overrides
settings in the "web.xml" file. Changing the configuration files in this way will normally require a re-start of the servlet container/application server for the changes to take effect. If the servlet container maintains session state between re-starts, by serializing session state to disc, the session state may need to be deleted.
The Icodeon Player supports customization of user interface devices. SCORM 2004 3rd Edition User Interface conformance requires that that SCORM run time environments provide learners with a minimum set of User Interface devices. Howver, because SCORM content often contains its own navigation devices, many vendors wish to remove devices from the run time environment. One way to do this is to customize the user interface devices of the Icodeon Player.
The user interface devices of the Icodeon Player are customized by editing a comma separated list of features for the configuration parameter name "uiFeatureList". Parameter values can be set in "web.xml" (application scope), System Properties/"player.properties" (application scope, overides web.xml) or request scope (overrides application scope):
<context-param>
<param-name>uiFeatureList</param-name>
<param-value>back,next,exit,toolbar</param-value>
</context-param>
The table below lists the vocabulary tokens supported for
each user interface feature. There is a special token of "blank" that displays the Icodeon
SCORM Player with no user interface controls. | Token | Description |
|---|---|
| back | Button to trigger SCORM "previous" navigation event |
| next | Button to trigger SCORM "continue" navigation event |
| exit | Button to trigger SCORM "exit" or "exitAll" navigation event |
| toolbar | Collapsible tool bar |
| organizations | Drop down combo box for multiple organizations |
| tree | Collapsible table of contents displayed as tree control |
| blank | No user interface devices |
Table 7.2. User Interface Devices Supported by the Icodeon Player
The title that appears of the Player toolbar is configured by setting the value of the parameter name "playerTitle". Parameter values can be set in "web.xml" (application scope), "player.properties" (application scope, overides web.xml) or request scope (overrides application scope). The example below shows "web.xml" configuration for application scope:
<context-param>
<param-name>playerTitle</param-name>
<param-value>Vendor Title and Brand</param-value>
</context-param>
The image below illustrate an example configurations:
The Icodeon Player is provided with four configurations for "look and feel". These configurations are known as user interface "skins". The "skin" is configured by setting the value of the parameter name "skinID". Parameter values can be set in "web.xml" (application scope), "player.properties" (application scope, overides web.xml) or request scope (overrides application scope). The example below shows "web.xml" configuration for application scope:
<context-param>
<param-name>skinID</param-name>
<param-value>aero</param-value>
</context-param>
The table below lists the vocabulary tokens supported for
each of the provided skins and a screen shot of each skin:
The Icodeon SCORM Player Version 2 (Java Edition) distribution is supplied with some sample HTML markup to show how the Player can be loaded into either a new window or an HTML frameset.
[PARENT DIRECTORY]/webapps/player2/index.html
[PARENT DIRECTORY]/webapps/player2/LMSPackages.aspx
[PARENT DIRECTORY]/webapps/player2/LMSFrameset.html
These files are not intended for production use and are not part of
the Icodeon SCORM Player Version 2 (Java Edition) application. The files are included to
guide web developers with an approach to integrating the Player into their own windows and
web pages. 
The Icodeon SCORM Player Version 2 within an HTML frameset [full size]
How the Icodeon SCORM Player Version 2 (Java Edition) is launched from a host LMS is an implementation decision for the LMS intgerator. The Player may be launched using a link with added URL parameters, or from a form, where parameters are added in hidden form fields. The Player may be launched into a new window or into an HTML frameset/IFrame within an LMS screen.
NOTE: Some SCORM content will attempt to close down a containing window. If the Player is added to an HTML frameset/IFrame within an LMS screen AND the SCORM content attempts to close down the LMS window, the user experiences the content closing an LMS session window. The example dynamic(.aspx)and static (.html) pages included with the distribution include example code for launching using HTML links and forms.
[PARENT DIRECTORY]/webapps/player2/index.html
[PARENT DIRECTORY]/webapps/player2/LMSPackages.aspx
[PARENT DIRECTORY]/webapps/player2/LMSFrameset.html
There a are a number of mandatory and optional parameters that will
need to be added to a launch link or a launch form. Optional parameters are also featured
in the "web.xml" file and the "player.propertie" file where they are used to determine the
behaviour for an instance of the application. If a parameter is used in a launch request
for a particular learner launch, then the launch parameter overrides the application scope
configuration parameter of the same name. In this way, individual learner sessions with
the Player can be tailored to the specific user. Typical launch parameters are listed in
the table below: | Parameter Name | Mandatory | Comment |
|---|---|---|
| learnerID | Yes | Used to populate the SCORM run time environment data model element cmi.learner_id. |
| courseID | Yes | Used to resolve the location of the directory containing the imsmanifest.xml file. |
| domainID | Yes | Used as a key to map to the location of the Hibernate configuration file. |
| learnerName | No (except for SCORM conformance testing) | Used to populate the SCORM run time environment data model element cmi.learner_name. If used, the format should be family name followed by first name separated by a comma. A middle intial can be added after space after the first name. Example: Student, Joseph A. |
| sessionID | No | This has no semantic meaning within the Icodeon Player and is simply persisted in the database table COCD. |
| skinID | No | Overrides the value set in application scope configuration. |
| uiFeatureList | No | Overrides the value set in application scope configuration. |
| playerTitle | No | Overrides the value set in application scope configuration. |
| culture | No | Overrides the value set in application scope configuration. |
Table 7.6. Launch Parameters for the Icodeon Player
Table of Contents
Detailed diagnostic information is required to identify the issue for resolution if there are errors reported by the Player. To provide vendors and Icodeon with this detailed diagnostic information, use the following steps:
Turn on server-side debugging in the log files. The server-side log level is specified in the log4j.properties configuration file. The file is located at:
[PARENT DIRECTORY]/webapps/player2/WEB-INF/classes/log4j.properties
The location and name of the log file should be
specified. If a relative path is given, the log file is written to a dirtectory
location relative to where the servlet container was started from:
log4j.appender.A1.file=logs/icodeon_player.log
The "log level" is set using a "level" (ERROR, WARN,
INFO, DEBUG) and a package namespace. For example, to configure debug information from
resolver plug-in components, the log4j.properties configuration file would be
configured with the line:
log4j.logger.com.icodeon.rte.plugins=DEBUG,Console,A1
Set error reporting to rich error reporting messaging: full debug information will be written to the user interface as well as the log files. The richness of error reporting is specified by turning on debug messages for the application "action" classes that response to HTTP requests.
log4j.logger.com.icodeon.rte.actions=DEBUG,Console,A1
The Icodeon SCORM Player Version 2 (Java Edition) makes use of advanced client-side JavaScript classes to manage SCORM behaviour and communication with web services. Errors in client-side behvaiour will not appear in the server side rich error reporting. To provide vendors and Icodeon with this detailed client-side diagnostic information, use the following steps:
Switch to using a FireFox browser for client side debugging. The error messaging from Java Script classes is more detailed in this browser.
Turn on AJAX logging for client side log messages. The debug and error messaging from Java Script classes will be recorded in a new browser (popup) window. Browsers used for client-side debug logging will need to be configured to allow popup windows. The client-side log level is specified by the "ajaxLogLevel" parameter, and this should be set to DEBUG:
<context-param>
<param-name>ajaxLogLevel</param-name>
<param-value>NONE</param-value>
</context-param>
From time to time Icodeon issue product updates. Customers will recieve automatic notification from Icodeon Customer Support when a new release is available for download. If the product update is a minor version change (for example, from Verison 2.09 to Version 2.10), then updated application files can normally be copied over an exisiting deployment, with the exception of configuration files and serial numbers, which will need to be back up and restored to the newly copied files:
[PARENT DIRECTORY]/wwwroot/web.config
[PARENT DIRECTORY]/wwwroot/serial_number.inf
The Player makes extensive use of client (browser) side Ajax libraries which may be cached locally in the browser. When testing the product update it is necessary to ensure that browser caches are refreshed to ensure the updated libraries are used by the browser.
This guide provides details for installing and configuring the Icodeon SCORM Player Version 2 (Java Edition) for typical evaluation and production deployments.
The Player provides the vendor with many customization options and extension points at which vendor "plug-ins" can be used to replace the default code provided by Icodeon. For support regarding further customization options and extension points go to http://support.icodeon.com

Support and help with the Icodeon SCORM Player Version 2 (Java Edition)
Table of Contents
The Icodeon SCORM Player Version 2 (Java Edition) comes with numerous configuration and customization options. However, sometimes these options provided by Icodeon do not meet the specific needs of a particular vendor.
To respond to this requirement, the Player has a number of "extension points" where the standard Icodeon implementation can be "removed" and a custom implementation "plugged-in". Icodeon provide some source code and full API documentaion to support vendors with their custom implementation work.

API Documentation to facilitate custom plug-in development
SCORM objects cache tracking data on the client, and periodically commit this state. SCORM refers to this tracking data as elements from the Computer Managed Instruction (or CMI) datamodel. In the Icodeon SCORM Player, this state is posted to a web service (the CMI SCORM Tracking Service) as an XML binding of the CMI state using the IEEE 1484.11.3 schema for Content Object Communication Data Model (or COCD). How the web service persists the data between invocations and sessions depends on which persistence strategy is "plugged-in" to the CMI service.
The distribution comes with two persistence strategies:
File system plug-in for persistence to the file system as XML
Database plug-in for persistence to a relational database through the NHibernate layer
TODO...
SCORM objects have a life cycle during a session within the Icodeon SCORM Player. The life cycle is characterized by the thee "data transfer" operations of the SCORM JavaScript API (IEEE 1484.11.2):
Initialize: Tracking data from a prevous session is sent from the server to the client.
Commit: Tracking data that has been recorded and cached on the client is sent to the server.
Terminate: Session time is calculated and tracking data that has been recorded and cached on the client is sent to the server.
Sometimes there will be a vendor requirement to observe these life cycle events, perhaps to trigger custom behaviour within another system. Icodeon provide the opportunity to "plug-in" a custom observer class to intercept these life cycle events and implement required functionality.

Custom plug-in observer for events in the CMI service
TODO...
Table of Contents
The SCORM specification, escpecially SCORM 2004, requires a lot of "state" to be maintained and processed and so there are inherent limits to the performance of SCORM run times.
TODO...
When the Player is launched, the mandatory parameter called:
courseID
must be included in the launch URL or form parameters. Launch
performance can be improved by adding the optional parameter called:
orgID
which is the identifier of the particular organization to be used
within the SCORM manifest file. By specifying the organization identifier in the launch, the
extra effort to read in the manifest file and determine the identifier is avoided, improving
launch performance.