OperatingSystemFamily.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.regex.Matcher;
  19. import java.util.regex.Pattern;

  21. import javax.annotation.Nonnull;

  23. import net.sf.qualitycheck.Check;

  25. /**
  26.  * This enum represents the more commonly used operating system families. It will never be complete, but can assist in
  27.  * identifying the version of an operating system.
  28.  * 
  29.  * @author André Rouél
  30.  */
  31. public enum OperatingSystemFamily {

  33.     /**
  34.      * AIX (Advanced Interactive eXecutive) is a Unix operating system from IBM.
  35.      */
  36.     AIX("AIX", Pattern.compile("AIX")),

  38.     /**
  39.      * AROS is a free operating system aiming at being compatible with AmigaOS at the API level.
  40.      */
  41.     AROS("AROS", Pattern.compile("AROS")),

  43.     /**
  44.      * AmigaOS is the native operating system for the Commodore Amiga, consisting of the components of Workbench,
  45.      * AmigaDOS with the command line interpreter CLI (later renamed to shell) and for many Amiga models in the ROM
  46.      * included kernel <i>kickstart</i>.
  47.      */
  48.     AMIGA_OS("Amiga OS", Pattern.compile("Amiga OS")),

  50.     /**
  51.      * Android is both an operating system and a software platform for mobile devices like smart phones, mobile phones,
  52.      * netbooks and tablets, which is developed by the Open Handset Alliance.
  53.      */
  54.     ANDROID("Android", Pattern.compile("Android")),

  56.     /**
  57.      * The Berkeley Software Distribution (BSD) is a version of the Unix operating system, which was created at the
  58.      * University of California at Berkeley in 1977.
  59.      */
  60.     BSD("BSD", Pattern.compile("BSD")),

  62.     /**
  63.      * Bada is a service-oriented operating system that is developed by Samsung Electronics and is designed for use in
  64.      * smartphones.
  65.      */
  66.     BADA("Bada", Pattern.compile("Bada")),

  68.     /**
  69.      * Be Operating System (BeOS) was an operating system of the company <i>Be Incorporated</i> and was called in later
  70.      * versions Be. Due to its multimedia capabilities it is also commonly called "Media OS".
  71.      */
  72.     BEOS("BeOS", Pattern.compile("BeOS")),

  74.     /**
  75.      * Danger OS is a smartphone operating system. It is used on Sidekick devices, which are sold in Germany by
  76.      * T-Mobile.
  77.      */
  78.     DANGEROS("DangerOS", Pattern.compile("DangerOS")),

  80.     /**
  81.      * Firefox OS is an open source operating system for smartphones and tablet computers being developed by Mozilla.
  82.      */
  83.     FIREFOX_OS("Firefox OS", Pattern.compile("Firefox OS")),

  85.     /**
  86.      * HP-UX (Hewlett Packard UniX) is a commercial Unix operating system from Hewlett-Packard and is based on UNIX
  87.      * System V.
  88.      */
  89.     HPUX("HP-UX", Pattern.compile("HP-UX")),

  91.     /**
  92.      * Haiku (formerly OpenBeOS) is an open-source project with the aim, to reprogram and expand that in 2001 abandoned
  93.      * operating system BeOS.
  94.      */
  95.     HAIKU("Haiku OS", Pattern.compile("Haiku OS")),

  97.     /**
  98.      * IRIX is a commercial Unix operating system of the company Silicon Graphics (SGI).
  99.      */
  100.     IRIX("IRIX", Pattern.compile("IRIX")),

  102.     /**
  103.      * Inferno is a distributed computer operating system that comes from Bell Laboratories.
  104.      */
  105.     INFERNO_OS("Inferno OS", Pattern.compile("Inferno OS")),

  107.     /**
  108.      * The Java Virtual Machine (abbreviated Java VM or JVM) is the part of the Java Runtime Environment (JRE) for Java
  109.      * programs, which is responsible for the execution of Java bytecode.<br>
  110.      * <br>
  111.      * This value is not an operating system family.
  112.      */
  113.     JVM("JVM", Pattern.compile("JVM")),

  115.     /**
  116.      * Linux or GNU/Linux are usually called free, unix-like multi-user operating systems running based on the Linux
  117.      * kernel and other GNU software.
  118.      */
  119.     LINUX("Linux", Pattern.compile("Linux")),

  121.     /**
  122.      * Mac OS is the name of the classic operating system (1984-2001) by Apple for Macintosh computers.
  123.      */
  124.     MAC_OS("Mac OS", Pattern.compile("Mac OS")),

  126.     /**
  127.      * MeeGo was a Linux kernel-based free mobile operating system project resulting from the fusion of Intel's Moblin
  128.      * and Nokia's Maemo operating systems.
  129.      */
  130.     MEEGO("MeeGo", Pattern.compile("MeeGo")),

  132.     /**
  133.      * Minix is a free unixoides operating system that was developed by Andrew S. Tanenbaum at the Free University of
  134.      * Amsterdam as a teaching tool.
  135.      */
  136.     MINIX("MINIX", Pattern.compile("MINIX")),

  138.     /**
  139.      * OpenVMS (Open Virtual Memory System), previously known as VAX-11/VMS, VAX/VMS or (informally) VMS, is a computer
  140.      * server operating system that runs on VAX, Alpha and Itanium-based families of computers.
  141.      */
  142.     OPENVMS("OpenVMS", Pattern.compile("OpenVMS")),

  144.     /**
  145.      * OS X, formerly Mac OS X, is a Unix-based operating systems developed by Apple. It is a proprietary distribution
  146.      * of the free Darwin operating system from Apple.
  147.      */
  148.     OS_X("OS X", Pattern.compile("(Mac OS X|OS X)")),

  150.     /**
  151.      * MorphOS is an Amiga-compatible computer operating system. It is a mixed proprietary and open source OS produced
  152.      * for the Pegasos PowerPC processor based computer.
  153.      */
  154.     MORPHOS("MorphOS", Pattern.compile("MorphOS")),

  156.     /**
  157.      * This value indicates the operating systems from Nintendo, which they developed for their devices.<br>
  158.      * <br>
  159.      * This value is not an operating system family.
  160.      */
  161.     NINTENDO("Nintendo", Pattern.compile("Nintendo")),

  163.     /**
  164.      * OS/2 is a multitasking operating system for PCs. It was originally developed by IBM and Microsoft together with
  165.      * the aim to replace DOS.
  166.      */
  167.     OS_2("OS/2", Pattern.compile("OS/2")),

  169.     /**
  170.      * Palm OS was the operating system for organizer of the Palm series (known as PDAs) and smartphones.
  171.      */
  172.     PALM_OS("Palm OS", Pattern.compile("Palm OS")),

  174.     /**
  175.      * The PlayStation Vita system software is the official, updatable firmware and operating system for the PlayStation
  176.      * Vita.
  177.      */
  178.     PLAYSTATION_VITA("LiveArea", Pattern.compile("LiveArea")),

  180.     /**
  181.      * QNX is a POSIX-compatible proprietary Unix-like real-time operating system that focused primarily at the embedded
  182.      * market.
  183.      */
  184.     QNX("QNX", Pattern.compile("QNX")),

  186.     /**
  187.      * RISC OS is a computer operating system originally designed by Acorn Computers Ltd. It was specifically designed
  188.      * to run on the ARM chipset, which Acorn had designed concurrently for use in its new line of Archimedes personal
  189.      * computers.
  190.      */
  191.     RISC_OS("RISC OS", Pattern.compile("RISC OS|RISK OS")),

  193.     /**
  194.      * Binary Runtime Environment for Wireless (Brew MP, Brew, or BREW) is an application development platform created
  195.      * by Qualcomm.
  196.      */
  197.     BREW("Brew", Pattern.compile("Brew")),

  199.     /**
  200.      * BlackBerry OS (up to the fifth edition known as the <i>BlackBerry Device Software</i>, also known as <i>Research
  201.      * In Motion OS</i>) is a proprietary mobile operating system developed by BlackBerry Ltd for its BlackBerry line of
  202.      * smartphone handheld devices.
  203.      */
  204.     BLACKBERRY_OS("BlackBerry OS", Pattern.compile("(RIM OS|BlackBerry OS)")),

  206.     /**
  207.      * Sailfish is a Linux-based mobile operating system developed by Jolla in cooperation with the Mer project and
  208.      * supported by the Sailfish Alliance.
  209.      */
  210.     SAILFISH_OS("Sailfish", Pattern.compile("Sailfish")),

  212.     /**
  213.      * Solaris is the name of an operating system distribution based on SunOS and is a Unix operating system. Since the
  214.      * takeover of Sun Microsystems in 2010 Solaris is part of Oracle.
  215.      */
  216.     SOLARIS("Solaris", Pattern.compile("Solaris")),

  218.     /**
  219.      * Syllable is a slim and fast desktop Unix-like operating system for x86 processors.
  220.      */
  221.     SYLLABLE("Syllable", Pattern.compile("Syllable")),

  223.     /**
  224.      * The Symbian platform, simply called Symbian, is an operating system for smartphones and PDAs. The Symbian
  225.      * platform is the successor to Symbian OS
  226.      */
  227.     SYMBIAN("Symbian OS", Pattern.compile("Symbian OS")),

  229.     /**
  230.      * Tizen is a free operating system based on Linux respectively Debian and was launched by the Linux Foundation and
  231.      * LiMo Foundation.
  232.      */
  233.     TIZEN("Tizen", Pattern.compile("Tizen")),

  235.     /**
  236.      * The Wii Operating System is based on Nintendo’s proprietary software and runs on the Wii video game console.
  237.      */
  238.     WII_OS("Wii OS", Pattern.compile("Nintendo Wii|Wii OS")),

  240.     /**
  241.      * Microsoft Windows is a trademark for operating systems of the Microsoft Corporation. Microsoft Windows was
  242.      * originally a graphical extension of the operating system MS-DOS.
  243.      */
  244.     WINDOWS("Windows", Pattern.compile("Windows")),

  246.     /**
  247.      * XrossMediaBar (XMB) is the name of the graphical user interface, which are used on PlayStation 3, PlayStation
  248.      * Portable, Sony Blu-Ray players and Sony Bravia TVs. Also some special versions of the PlayStation 2, PSX, already
  249.      * using the XMB.
  250.      */
  251.     XROSSMEDIABAR("XrossMediaBar (XMB)", Pattern.compile("XrossMediaBar (XMB)")),

  253.     /**
  254.      * iOS (until June 2010 iPhone OS) is the standard operating system of Apple products like iPhone, iPod touch, iPad,
  255.      * and the second generation of Apple TV. iOS is based on Mac OS X.
  256.      */
  257.     IOS("iOS", Pattern.compile("iOS|iPhone OS")),

  259.     /**
  260.      * webOS is a smartphone and tablet operating system from Hewlett-Packard (formerly HP Palm). It represents the
  261.      * follower of Palm OS.
  262.      */
  263.     WEBOS("webOS", Pattern.compile("webOS")),

  265.     /**
  266.      * Unknown operating system family<br>
  267.      * <br>
  268.      * This value will be returned if the operating system family cannot be determined.
  269.      */
  270.     UNKNOWN("", Pattern.compile("^$"));

  272.     /**
  273.      * This method try to find by the given family name a matching enum value. The family name must match against an
  274.      * operating system entry in UAS data file.
  275.      * 
  276.      * @param family
  277.      *            name of an operating system family
  278.      * @return the matching enum value or {@code OperatingSystemFamily#UNKNOWN}
  279.      * @throws net.sf.qualitycheck.exception.IllegalNullArgumentException
  280.      *             if the given argument is {@code null}
  281.      */
  282.     public static OperatingSystemFamily evaluate(@Nonnull final String family) {
  283.         Check.notNull(family, "family");

  285.         OperatingSystemFamily result = UNKNOWN;

  287.         // search by name
  288.         result = evaluateByName(family);

  290.         // search by pattern
  291.         if (result == UNKNOWN) {
  292.             result = evaluateByPattern(family);
  293.         }

  295.         return result;
  296.     }

  298.     /**
  299.      * This method try to find by the given family name a matching enum value. The family name will be evaluated against
  300.      * the stored name of an operating system entry.
  301.      * 
  302.      * @param family
  303.      *            name of an operating system family
  304.      * @return the matching enum value or {@code OperatingSystemFamily#UNKNOWN}
  305.      * @throws net.sf.qualitycheck.exception.IllegalNullArgumentException
  306.      *             if the given argument is {@code null}
  307.      */
  308.     protected static OperatingSystemFamily evaluateByName(@Nonnull final String family) {
  309.         Check.notNull(family, "family");

  311.         OperatingSystemFamily result = UNKNOWN;
  312.         for (final OperatingSystemFamily value : values()) {
  313.             if (value.getName().equals(family)) {
  314.                 result = value;
  315.                 break;
  316.             }
  317.         }

  319.         return result;
  320.     }

  322.     /**
  323.      * This method try to find by the given family name a matching enum value. The family name will be evaluated against
  324.      * the stored regular expression of an operating system entry.
  325.      * 
  326.      * @param family
  327.      *            name of an operating system family
  328.      * @return the matching enum value or {@code OperatingSystemFamily#UNKNOWN}
  329.      * @throws net.sf.qualitycheck.exception.IllegalNullArgumentException
  330.      *             if the given argument is {@code null}
  331.      */
  332.     protected static OperatingSystemFamily evaluateByPattern(@Nonnull final String family) {
  333.         Check.notNull(family, "family");

  335.         OperatingSystemFamily result = UNKNOWN;
  336.         for (final OperatingSystemFamily value : values()) {
  337.             final Matcher m = value.getPattern().matcher(family);
  338.             if (m.matches()) {
  339.                 result = value;
  340.                 break;
  341.             }
  342.         }

  344.         return result;
  345.     }

  347.     /**
  348.      * The internal family name in the UAS database.
  349.      */
  350.     @Nonnull
  351.     private final String name;

  353.     /**
  354.      * The regular expression which a family name must be match.
  355.      */
  356.     @Nonnull
  357.     private final Pattern pattern;

  359.     private OperatingSystemFamily(@Nonnull final String name, @Nonnull final Pattern pattern) {
  360.         this.name = name;
  361.         this.pattern = pattern;
  362.     }

  364.     /**
  365.      * Gets the internal family name in the UAS database.
  366.      * 
  367.      * @return the internal family name
  368.      */
  369.     @Nonnull
  370.     public String getName() {
  371.         return this.name;
  372.     }

  374.     /**
  375.      * Gets the regular expression which a family name must be match with.
  376.      * 
  377.      * @return regular expression
  378.      */
  379.     @Nonnull
  380.     public Pattern getPattern() {
  381.         return pattern;
  382.     }

  384. }
Created with JaCoCo 0.6.2.201302030002