VersionParser.java

  1. /*******************************************************************************
  2.  * Copyright 2012 André Rouél
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  *   http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  ******************************************************************************/
  16. package net.sf.uadetector;

  18. import java.util.ArrayList;
  19. import java.util.Arrays;
  20. import java.util.List;
  21. import java.util.regex.Matcher;
  22. import java.util.regex.Pattern;

  24. import javax.annotation.Nonnull;

  26. import net.sf.qualitycheck.Check;

  28. /**
  29.  * This class is used to detect version information within <i>User-Agent</i> strings.
  30.  * 
  31.  * @author André Rouél
  32.  */
  33. final class VersionParser {

  35.     /**
  36.      * Index number of the group in a matching {@link Pattern} which contains the extension/suffix of a version string
  37.      */
  38.     private static final int EXTENSION_INDEX = 5;

  40.     /**
  41.      * Index number of the group in a matching {@link Pattern} which contains the first/major number of a version string
  42.      */
  43.     private static final int MAJOR_INDEX = 1;

  45.     /**
  46.      * Regular expression to analyze a version number separated by a dot
  47.      */
  48.     private static final Pattern VERSIONNUMBER = Pattern.compile("((\\d+)((\\.\\d+)+)?)");

  50.     /**
  51.      * Regular expression to analyze a version number separated by a dot with suffix
  52.      */
  53.     private static final Pattern VERSIONNUMBER_WITH_SUFFIX = Pattern.compile(VERSIONNUMBER.pattern() + "((\\s|\\-|\\.|\\[|\\]|\\w+)+)?");

  55.     /**
  56.      * Regular expression to analyze segments of a version string, consisting of prefix, numeric groups and suffix
  57.      */
  58.     private static final Pattern VERSIONSTRING = Pattern.compile("^" + VERSIONNUMBER_WITH_SUFFIX.pattern());

  60.     /**
  61.      * This method try to determine the version number of the operating system <i>Android</i> more accurately.
  62.      * 
  63.      * @param userAgent
  64.      *            user agent string
  65.      * @return more accurately identified version number or {@code null}
  66.      */
  67.     static VersionNumber identifyAndroidVersion(@Nonnull final String userAgent) {
  68.         VersionNumber version = VersionNumber.UNKNOWN;
  69.         final List<Pattern> patterns = new ArrayList<Pattern>();
  70.         patterns.add(Pattern.compile("Android\\s?((\\d+)((\\.\\d+)+)?(\\-(\\w|\\d)+)?);"));
  71.         patterns.add(Pattern.compile("Android\\-((\\d+)((\\.\\d+)+)?(\\-(\\w|\\d)+)?);"));
  72.         for (final Pattern pattern : patterns) {
  73.             final Matcher m = pattern.matcher(userAgent);
  74.             if (m.find()) {
  75.                 version = parseFirstVersionNumber(m.group(MAJOR_INDEX));
  76.                 break;
  77.             }
  78.         }
  79.         return version;
  80.     }

  82.     /**
  83.      * This method try to determine the version number of the operating system <i>Bada</i> more accurately.
  84.      * 
  85.      * @param userAgent
  86.      *            user agent string
  87.      * @return more accurately identified version number or {@code null}
  88.      */
  89.     static VersionNumber identifyBadaVersion(final String userAgent) {
  90.         VersionNumber version = VersionNumber.UNKNOWN;
  91.         final Pattern pattern = Pattern.compile("Bada/((\\d+)((\\.\\d+)+)?)");
  92.         final Matcher m = pattern.matcher(userAgent);
  93.         if (m.find()) {
  94.             version = parseFirstVersionNumber(m.group(MAJOR_INDEX));
  95.         }
  96.         return version;
  97.     }

  99.     /**
  100.      * This method try to determine the version number of an operating system of a <i>BSD</i> platform more accurately.
  101.      * 
  102.      * @param userAgent
  103.      *            user agent string
  104.      * @return more accurately identified version number or {@code null}
  105.      */
  106.     static VersionNumber identifyBSDVersion(final String userAgent) {
  107.         VersionNumber version = VersionNumber.UNKNOWN;
  108.         final Pattern pattern = Pattern.compile("\\w+bsd\\s?((\\d+)((\\.\\d+)+)?((\\-|_)[\\w\\d\\-]+)?)", Pattern.CASE_INSENSITIVE);
  109.         final Matcher m = pattern.matcher(userAgent);
  110.         if (m.find()) {
  111.             version = parseFirstVersionNumber(m.group(MAJOR_INDEX));
  112.         }
  113.         return version;
  114.     }

  116.     /**
  117.      * This method try to determine the version number of the operating system <i>iOS</i> more accurately.
  118.      * 
  119.      * @param userAgent
  120.      *            user agent string
  121.      * @return more accurately identified version number or {@code null}
  122.      */
  123.     static VersionNumber identifyIOSVersion(final String userAgent) {
  124.         VersionNumber version = VersionNumber.UNKNOWN;
  125.         final List<Pattern> patterns = new ArrayList<Pattern>();
  126.         patterns.add(Pattern.compile("iPhone OS\\s?((\\d+)((\\_\\d+)+)?) like Mac OS X"));
  127.         patterns.add(Pattern.compile("CPU OS\\s?((\\d+)((\\_\\d+)+)?) like Mac OS X"));
  128.         patterns.add(Pattern.compile("iPhone OS\\s?((\\d+)((\\.\\d+)+)?);"));
  129.         for (final Pattern pattern : patterns) {
  130.             final Matcher m = pattern.matcher(userAgent);
  131.             if (m.find()) {
  132.                 version = parseFirstVersionNumber(m.group(MAJOR_INDEX).replaceAll("_", "."));
  133.                 break;
  134.             }
  135.         }
  136.         return version;
  137.     }

  139.     /**
  140.      * This method try to determine the version number of the running <i>JVM</i> more accurately.
  141.      * 
  142.      * @param userAgent
  143.      *            user agent string
  144.      * @return more accurately identified version number or {@code null}
  145.      */
  146.     static VersionNumber identifyJavaVersion(final String userAgent) {
  147.         VersionNumber version = VersionNumber.UNKNOWN;
  148.         final List<Pattern> patterns = new ArrayList<Pattern>();
  149.         patterns.add(Pattern.compile("Java/((\\d+)((\\.\\d+)+)?((\\-|_)[\\w\\d\\-]+)?)"));
  150.         patterns.add(Pattern.compile("Java((\\d+)((\\.\\d+)+)?((\\-|_)[\\w\\d\\-]+)?)"));
  151.         for (final Pattern pattern : patterns) {
  152.             final Matcher m = pattern.matcher(userAgent);
  153.             if (m.find()) {
  154.                 version = parseFirstVersionNumber(m.group(MAJOR_INDEX));
  155.                 break;
  156.             }
  157.         }
  158.         return version;
  159.     }

  161.     /**
  162.      * This method try to determine the version number of the operating system <i>OS X</i> more accurately.
  163.      * 
  164.      * @param userAgent
  165.      *            user agent string
  166.      * @return more accurately identified version number or {@code null}
  167.      */
  168.     static VersionNumber identifyOSXVersion(final String userAgent) {
  169.         VersionNumber version = VersionNumber.UNKNOWN;
  170.         final List<Pattern> patterns = new ArrayList<Pattern>();
  171.         patterns.add(Pattern.compile("Mac OS X\\s?((\\d+)((\\.\\d+)+)?);"));
  172.         patterns.add(Pattern.compile("Mac OS X\\s?((\\d+)((\\_\\d+)+)?);"));
  173.         patterns.add(Pattern.compile("Mac OS X\\s?((\\d+)((\\_\\d+)+)?)\\)"));
  174.         for (final Pattern pattern : patterns) {
  175.             final Matcher m = pattern.matcher(userAgent);
  176.             if (m.find()) {
  177.                 version = parseFirstVersionNumber(m.group(MAJOR_INDEX).replaceAll("_", "."));
  178.                 break;
  179.             }
  180.         }
  181.         return version;
  182.     }

  184.     /**
  185.      * This method try to determine the version number of the operating system <i>Symbian</i> more accurately.
  186.      * 
  187.      * @param userAgent
  188.      *            user agent string
  189.      * @return more accurately identified version number or {@code null}
  190.      */
  191.     static VersionNumber identifySymbianVersion(final String userAgent) {
  192.         VersionNumber version = VersionNumber.UNKNOWN;
  193.         final Pattern pattern = Pattern.compile("SymbianOS/((\\d+)((\\.\\d+)+)?s?)");
  194.         final Matcher m = pattern.matcher(userAgent);
  195.         if (m.find()) {
  196.             version = parseFirstVersionNumber(m.group(MAJOR_INDEX));
  197.         }
  198.         return version;
  199.     }

  201.     /**
  202.      * This method try to determine the version number of the operating system <i>webOS</i> more accurately.
  203.      * 
  204.      * @param userAgent
  205.      *            user agent string
  206.      * @return more accurately identified version number or {@code null}
  207.      */
  208.     static VersionNumber identifyWebOSVersion(final String userAgent) {
  209.         VersionNumber version = VersionNumber.UNKNOWN;
  210.         final List<Pattern> patterns = new ArrayList<Pattern>();
  211.         patterns.add(Pattern.compile("hpwOS/((\\d+)((\\.\\d+)+)?);"));
  212.         patterns.add(Pattern.compile("webOS/((\\d+)((\\.\\d+)+)?);"));
  213.         for (final Pattern pattern : patterns) {
  214.             final Matcher m = pattern.matcher(userAgent);
  215.             if (m.find()) {
  216.                 version = parseFirstVersionNumber(m.group(MAJOR_INDEX));
  217.                 break;
  218.             }
  219.         }
  220.         return version;
  221.     }

  223.     /**
  224.      * This method try to determine the version number of the operating system <i>Windows</i> more accurately.
  225.      * 
  226.      * @param userAgent
  227.      *            user agent string
  228.      * @return more accurately identified version number or {@code null}
  229.      */
  230.     static VersionNumber identifyWindowsVersion(final String userAgent) {
  231.         VersionNumber version = VersionNumber.UNKNOWN;
  232.         final List<Pattern> patterns = new ArrayList<Pattern>();
  233.         patterns.add(Pattern.compile("Windows NT\\s?((\\d+)((\\.\\d+)+)?)"));
  234.         patterns.add(Pattern.compile("Windows Phone OS ((\\d+)((\\.\\d+)+)?)"));
  235.         patterns.add(Pattern.compile("Windows CE ((\\d+)((\\.\\d+)+)?)"));
  236.         patterns.add(Pattern.compile("Windows 2000\\s?((\\d+)((\\.\\d+)+)?)"));
  237.         patterns.add(Pattern.compile("Windows XP\\s?((\\d+)((\\.\\d+)+)?)"));
  238.         patterns.add(Pattern.compile("Windows 7\\s?((\\d+)((\\.\\d+)+)?)"));
  239.         patterns.add(Pattern.compile("Win 9x ((\\d+)((\\.\\d+)+)?)"));
  240.         patterns.add(Pattern.compile("Windows ((\\d+)((\\.\\d+)+)?)"));
  241.         patterns.add(Pattern.compile("WebTV/((\\d+)((\\.\\d+)+)?)"));
  242.         for (final Pattern pattern : patterns) {
  243.             final Matcher m = pattern.matcher(userAgent);
  244.             if (m.find()) {
  245.                 version = parseFirstVersionNumber(m.group(MAJOR_INDEX));
  246.                 break;
  247.             }
  248.         }
  249.         return version;
  250.     }

  252.     /**
  253.      * Interprets a string with version information. The first occurrence of a version number in the string will be
  254.      * searched and processed.
  255.      * 
  256.      * @param text
  257.      *            string with version information
  258.      * @return an object of {@code VersionNumber}, never {@code null}
  259.      */
  260.     static VersionNumber parseFirstVersionNumber(@Nonnull final String text) {
  261.         Check.notNull(text, "text");

  263.         final Matcher matcher = VERSIONNUMBER_WITH_SUFFIX.matcher(text);
  264.         String[] split = null;
  265.         String ext = null;
  266.         if (matcher.find()) {
  267.             split = matcher.group(MAJOR_INDEX).split("\\.");
  268.             ext = matcher.group(EXTENSION_INDEX);
  269.         }

  271.         final String extension = ext == null ? VersionNumber.EMPTY_EXTENSION : trimRight(ext);

  273.         return split == null ? VersionNumber.UNKNOWN : new VersionNumber(Arrays.asList(split), extension);
  274.     }

  276.     /**
  277.      * Interprets a string with version information. The last version number in the string will be searched and
  278.      * processed.
  279.      * 
  280.      * @param text
  281.      *            string with version information
  282.      * @return an object of {@code VersionNumber}, never {@code null}
  283.      */
  284.     public static VersionNumber parseLastVersionNumber(@Nonnull final String text) {
  285.         Check.notNull(text, "text");

  287.         final Matcher matcher = VERSIONNUMBER_WITH_SUFFIX.matcher(text);
  288.         String[] split = null;
  289.         String ext = null;
  290.         while (matcher.find()) {
  291.             split = matcher.group(MAJOR_INDEX).split("\\.");
  292.             ext = matcher.group(EXTENSION_INDEX);
  293.         }

  295.         final String extension = ext == null ? VersionNumber.EMPTY_EXTENSION : trimRight(ext);

  297.         return split == null ? VersionNumber.UNKNOWN : new VersionNumber(Arrays.asList(split), extension);
  298.     }

  300.     /**
  301.      * Try to determine the version number of the operating system by parsing the user agent string.
  302.      * 
  303.      * 
  304.      * @param family
  305.      *            family of the operating system
  306.      * @param userAgent
  307.      *            user agent string
  308.      * @return extracted version number
  309.      */
  310.     public static VersionNumber parseOperatingSystemVersion(@Nonnull final OperatingSystemFamily family, @Nonnull final String userAgent) {
  311.         Check.notNull(family, "family");
  312.         Check.notNull(userAgent, "userAgent");

  314.         final VersionNumber v;
  315.         if (OperatingSystemFamily.ANDROID == family) {
  316.             v = identifyAndroidVersion(userAgent);
  317.         } else if (OperatingSystemFamily.BADA == family) {
  318.             v = identifyBadaVersion(userAgent);
  319.         } else if (OperatingSystemFamily.BSD == family) {
  320.             v = identifyBSDVersion(userAgent);
  321.         } else if (OperatingSystemFamily.IOS == family) {
  322.             v = identifyIOSVersion(userAgent);
  323.         } else if (OperatingSystemFamily.JVM == family) {
  324.             v = identifyJavaVersion(userAgent);
  325.         } else if (OperatingSystemFamily.OS_X == family) {
  326.             v = identifyOSXVersion(userAgent);
  327.         } else if (OperatingSystemFamily.SYMBIAN == family) {
  328.             v = identifySymbianVersion(userAgent);
  329.         } else if (OperatingSystemFamily.WEBOS == family) {
  330.             v = identifyWebOSVersion(userAgent);
  331.         } else if (OperatingSystemFamily.WINDOWS == family) {
  332.             v = identifyWindowsVersion(userAgent);
  333.         } else {
  334.             v = VersionNumber.UNKNOWN;
  335.         }
  336.         return v;
  337.     }

  339.     /**
  340.      * Interprets a string with version information. The first found group will be taken and processed.
  341.      * 
  342.      * @param version
  343.      *            version as string
  344.      * @return an object of {@code VersionNumber}, never {@code null}
  345.      */
  346.     public static VersionNumber parseVersion(@Nonnull final String version) {
  347.         Check.notNull(version, "version");

  349.         VersionNumber result = new VersionNumber(new ArrayList<String>(0), version);
  350.         final Matcher matcher = VERSIONSTRING.matcher(version);
  351.         if (matcher.find()) {
  352.             final List<String> groups = Arrays.asList(matcher.group(MAJOR_INDEX).split("\\."));
  353.             final String extension = matcher.group(EXTENSION_INDEX) == null ? VersionNumber.EMPTY_EXTENSION : trimRight(matcher
  354.                     .group(EXTENSION_INDEX));
  355.             result = new VersionNumber(groups, extension);
  356.         }

  358.         return result;
  359.     }

  361.     /**
  362.      * Trims the whitespace at the end of the given string.
  363.      * 
  364.      * @param text
  365.      *            string to trim
  366.      * @return trimmed string
  367.      */
  368.     private static String trimRight(@Nonnull final String text) {
  369.         return text.replaceAll("\\s+$", "");
  370.     }

  372.     /**
  373.      * <strong>Attention:</strong> This class is not intended to create objects from it.
  374.      */
  375.     private VersionParser() {
  376.         // This class is not intended to create objects from it.
  377.     }

  379. }
Created with JaCoCo 0.6.2.201302030002