PluginDetect.getVersion('RealPlayer'): [Returns string or null]
   Returns the version (as a string) of the installed RealPlayer plugin.
   Returns null when the version could not be determined (when plugin is not installed/not enabled, or plugin is installed but the version information is unavailable).

By default, the returned version string is comma delimited and has the format of "A,B,C,D". If you wish to change the getVersion() delimiter, then use:
   PluginDetect.getVersion(delimiter) where delimiter is a string with exactly 1 character.

For example,
   PluginDetect.getVersion(".");   // set delimiter
   var version = PluginDetect.getVersion("RealPlayer");    // version has the format of "A.B.C.D"


PluginDetect.isMinVersion('RealPlayer', minVersion, mimetype): [Returns number]
   Returns 1 if RealPlayer is installed (& enabled) for the specified mimetype and plugin version is >= minVersion.
   Returns 0 if RealPlayer is installed (& enabled) for the specified mimetype. The plugin version is unknown, and thus we are unable to determine if version >= minVersion.
   Returns -0.1 if plugin is installed & enabled for the specified mimetype, but plugin version is < minVersion.
   Returns -0.2 if plugin is installed but not enabled for the specified mimetype. This means that the RealPlayer plugin is present, but the browser will not use the RealPlayer plugin to display a file with that mimetype. If there is a 3rd party plugin asociated with that mimetype, then it (instead of RealPlayer) will be used by the browser to display the file with that mimetype.
   Returns -1 if plugin is not installed or not enabled.
   Returns -2 if ActiveX is disabled (for Internet Explorer, this prevents plugin detection).
   Returns -3 if you supplied a bad input argument to the isMinVersion() method.


minVersion: [string or number input argument]
   This is the minimum plugin version.
   Can be a string such as  '1,5,0,0' or '1.5' or '1,5,0,1' or '1.5.0.1' etc...
   Can be a number such as 0 or 1.5 or 1.50 etc...
   If minVersion is not specified, then PluginDetect will assume minVersion is '0'.
   Strings are more versatile than numbers since '1,5,0,1' cannot be expressed as a number.


mimetype: [string, optional input argument]
   The mimetype input is only used by PluginDetect for non-Internet Explorer browsers. It is ignored if the browser is Internet Explorer.
   If mimetype input is not a string, or is an empty string, or is a string with only space characters in it, or is not specified at all, then PluginDetect will assume a default value of "audio/x-pn-realaudio-plugin". Most people will not need to specify any mimetype, and therefore the default value is assumed.
   Spaces in the mimetype input string are ignored. The mimetype input string is case sensitive.

1) Basic RealPlayer - the kind that most end users will have.

2) RealPlayer Plus - a paid version that has extra features. I believe the version numbers for the Plus are the same as the version numbers for the Basic.

3) RealPlayer Enterprise - a configurable player designed for corporate and education deployments. The version numbers for Enterprise are different from the version numbers of the basic/Plus RealPlayers.

4) Desktop vs mobile. I believe the version numbers for RealPlayer on mobile devices are different from the version numbers for RealPlayer on desktop computers.

PluginDetect will always try to determine whether the RealPlayer plugin is installed or not in your browser, regardless of the OS or platform.

PluginDetect will always try to get the RealPlayer plugin version for Windows/Mac (desktop). PluginDetect will NOT try to get the plugin version for any other OS or platform.



Plugin Version Precision

The RealPlayer plugin version is detected by PluginDetect.getVersion('RealPlayer'). The getVersion() method will return a value of either null or a string of 4 numbers "A,B,C,D" separated by a comma. Each of these 4 numbers is an integer >=0. When a version is detectable, then usually all 4 numbers "A,B,C,D" will be detected.

The version can only be detected on certain platforms. For example, PluginDetect will return a plugin version # for Windows and Mac, but not Linux.

The precision of the detected plugin version may vary between browsers. The reason for this discrepancy is that the amount of information available to PluginDetect can vary between browsers. For example, for RealPlayer 11 on Windows/Firefox, the last digit "D" will have some uncertainty.

Note: under Windows, the RealPlayer plugin version may not necessarily be exactly the same as the RealPlayer parent application version/build.



RealPlayer in Windows

The version numbers for RealPlayer under Windows are very confusing to me. As near as I can tell, there are 4 numbers that can identify RealPlayer. They are:

1) The RealPlayer Release Version. Shown in the "About Realplayer" dialog box. This is the version of the RealPlayer parent application, not the version of the RealPlayer plugin.
2) The standalone build number. Shown in the "About RealPlayer" dialog box. This is the build of the RealPlayer parent application.
3) The standalone installer version. When you look at a RealPlayer standalone installer file, right-click, and go to Properties. You will find a version #.
4) The RealPlayer browser plugin version. PluginDetect.getVersion("RealPlayer") will try to return the plugin version whenever possible. PluginDetect usually obtains this number by instantiating RealPlayer (either as an ActiveX control or as an embedded app in a web page), and then calling RealPlayer's GetVersionInfo( ) method. [The browser plugin makes it possible for RealPlayer to be embedded in a web page.]

There are a number of observations we can make based on the table above. I will number them so they make sense :-)

1) PluginDetect will always try to return the value of the plugin version, as given by the RealPlayer GetVersionInfo( ) method. This is done so as to be consistent with other RealPlayer detection scripts. The navigator.plugins array usually does not provide this information, which is why PluginDetect must instantiate RealPlayer to get the plugin version.

2) You should note that the same plugin version can refer to more than one release version for RealPlayer.
For example, plugin version 12.0.0.297 refers to RealPlayer SP 1.0 thru RealPlayer SP 1.0.5. I do not know why they did this, but it would have been much better to have a unique plugin version for each release version. So when PluginDetect.getVersion('RealPlayer') returns a value, one does not know exactly which release version / build # that it refers to.

3) The above table does not list all possible versions of RealPlayer. For example, the above table lists RealPlayer SP 1.0 and SP 1.0.2 in consecutive order, but it is possible that at least one or more versions were released in between SP 1.0 and SP 1.0.2. It's just that I was unable to find any installers or any published data for those in between.

4) The presence of a question mark (?) in the above table for the Digital Signature Timestamp indicates that I was unable to obtain an installer for that particular RealPlayer version. In that case, the data for that version came from a published source as opposed to actually testing that RealPlayer.

5) For Internet Explorer, PluginDetect uses the GetVersionInfo( ) method to get the plugin version. This has worked consistently well for all RealPlayer versions tested.

6a) For all other browsers (ie. Firefox, Chrome, Opera, etc...) the GetVersionInfo( ) method only works for RealPlayer 12 and higher. For RealPlayer < 12, PluginDetect uses the navigator.plugins array to obtain the plugin version. For RealPlayer 11, the navigator.plugins array can only give us the approximate value (ie. the minimum value) for the plugin version. For RealPlayer < 11, the navigator.plugins array appears to give the exact plugin version.

6b) For Chrome 10+, we will not instantiate RealPlayer to get the plugin version. The reason is that Chrome appears to give a popup when you try to run an outdated plugin. From a security standpoint, this is reasonable. But from a plugin detection standpoint, this is annoying.

7) The numbers in the above table can be discontinuous from one major release to the next. For example, when going from RealPlayer 10.5 to RealPlayer 11 (release versions), the plugin version skips from 6.0.12.xx to 11.0.0.yy. Also, notice how the plugin version skips from 12 to 14. Looks like a case of triskaidekaphobia to me.

8) It looks like RealPlayer 14 does not have a standalone build number. Perhaps RealNetworks decided to simplify things and just get rid of the standalone build number? I do not know if this is a new policy from RealNetworks.

9) And finally, lets make some suggestions here to RealNetworks. Maybe in the future, the RealPlayer version numbers could be derived from a random number generator. So each time you look at the version, it could randomly change. Or what about using transcendental numbers for the RealPlayer versions? That would really make things fun, don't ya think? And let's not forget about fractions, or even imaginary numbers. Come on, RealNetworks, let's make those version numbers more exciting! Let's spice things up! The sky is the limit!!!



RealPlayer in other Platforms

For Macintosh, PluginDetect obtains the RealPlayer plugin version by instantiating the Player in the web page, and querying the app. The plugin versions appear to match the RealPlayer release versions. [This is a more reasonable result than that found on Windows, where the plugin version numbers have often differed from the release/build numbers.]

For Linux, PluginDetect cannot obtain the plugin version by any means. PluginDetect can only tell you whether RealPlayer is installed or not installed. [RealPlayer 11 is the last known version released for this platform. RealPlayer is no longer being developed for Linux.]

For all other platforms (including mobile devices), PluginDetect will only tell you if the RealPlayer plugin is installed or not installed in your browser. No attempt will even be made to obtain the plugin version. Why? Because RealNetworks does not seem to want to put any useful info into the navigator array, and simply instantiating RealPlayer on all platforms seems a bit too open ended. My hesitancy here is a result of all the confusion with version numbers on the Windows platform. Also, the release version numbers on mobile platforms most likely are not similar to the release version numbers on the desktop platforms.



Specifying minVersion for RealPlayer plugin detection

Usually when we detect a plugin, we only need to specify a single value for minVersion for all platforms.
For example,

var PD = PluginDetect, status, isInstalled, minVersion;

minVersion = "5";   // same value for all platforms
isInstalled = PD.isMinVersion(pluginName, '0') >=0 ? true : false;
status = PD.isMinVersion(pluginName, minVersion);

if (status==1){  
      // plugin installed & enabled, plugin version >= minVersion
}
else if (status==0){
     // plugin installed & enabled, plugin version not detected
}
else if (status==-0.1){
     // plugin installed & enabled, plugin version < minVersion
}
else if (status==-0.2){
     // plugin installed but not enabled
}
else if (status==-1){
    // plugin not installed or not enabled
}
else if (status==-2){
      // Active X disabled in Internet Explorer. Unable to detect plugins.
}

One problem with this approach is that the RealPlayer plugin version numbers may differ depending on the Operating System / platform. For example, suppose we have RealPlayer 11.1.3 (release version). On Windows, the corresponding plugin version would be 11.0.0.663. On a Macintosh, the corresponding plugin version might be 11.1.3.0.

And who even knows what the corresponding release version/plugin version for RealPlayer may be on a specific mobile device? There are lots of mobile devices, and RealPlayer mobile is probably customized for some of these devices.

For whatever reason, you may just want a unique minVersion for each platform. To deal with this possibility, we modify the previous example slightly:

var PD = PluginDetect, status, isInstalled, minVersion;

if (PD.OS == 1) minVersion="14";  // Windows
else if (PD.OS == 2) minVersion="12";  // Macintosh
else minVersion="0";         // All other platforms

isInstalled = PD.isMinVersion("RealPlayer", '0') >=0 ? true : false;
status = PD.isMinVersion("RealPlayer", minVersion);

if (status==1){  
      // plugin installed & enabled, plugin version >= minVersion
}
else if (status==0){
     // plugin installed & enabled, plugin version not detected
}
else if (status==-0.1){
     // plugin installed & enabled, plugin version < minVersion
}
else if (status==-0.2){
     // plugin installed but not enabled
}
else if (status==-1){
    // plugin not installed or not enabled
}
else if (status==-2){
      // Active X disabled in Internet Explorer. Unable to detect plugins.
}