コード例 #1
0
 /**
  * Allows user to target several browsers. The names of potential browsers can be accessed via the
  * {@link #getBrowserList() getBrowserList} method.
  *
  * <p>The browsers from the list will be tried in order (first to last) until one of the calls
  * succeeds. If all the calls to the requested browsers fail, the code will fail over to the
  * default browser.
  *
  * @param browsers List
  * @param urlString String
  * @throws UnsupportedOperatingSystemException
  * @throws BrowserLaunchingExecutionException
  * @throws BrowserLaunchingInitializingException
  */
 public void openUrl(List browsers, String urlString)
     throws UnsupportedOperatingSystemException, BrowserLaunchingExecutionException,
         BrowserLaunchingInitializingException {
   if (browsers == null || browsers.isEmpty()) {
     logger.debug("falling through to non-targetted openUrl");
     openUrl(urlString);
   } else {
     String protocol = null;
     try {
       protocol = getProtocol(urlString);
     } catch (MalformedURLException malrulex) {
       throw new BrowserLaunchingExecutionException(malrulex);
     }
     Map browserMap = getBrowserMap();
     boolean success = false;
     Iterator iter = browsers.iterator();
     while (iter.hasNext() && !success) {
       WindowsBrowser winBrowser = (WindowsBrowser) browserMap.get(iter.next());
       if (winBrowser != null) {
         success = openUrlWithBrowser(winBrowser, protocol, urlString);
       }
     }
     if (!success) {
       logger.debug("none of listed browsers succeeded; falling through to non-targetted openUrl");
       openUrl(urlString);
     }
   }
 }
コード例 #2
0
 /**
  * Attempts to open a url with the specified browser. This is a utility method called by the
  * openUrl methods.
  *
  * @param winBrowser WindowsBrowser
  * @param protocol String
  * @param urlString String
  * @return boolean
  * @throws BrowserLaunchingExecutionException
  */
 private boolean openUrlWithBrowser(WindowsBrowser winBrowser, String protocol, String urlString)
     throws BrowserLaunchingExecutionException {
   boolean success = false;
   try {
     logger.info(winBrowser.getBrowserDisplayName());
     logger.info(urlString);
     logger.info(protocol);
     String args = getCommandArgs(protocol, winBrowser, urlString, forceNewWindow);
     if (logger.isDebugEnabled()) {
       logger.debug(args);
     }
     Process process = Runtime.getRuntime().exec(args);
     // This avoids a memory leak on some versions of Java on Windows.
     // That's hinted at in <http://developer.java.sun.com/developer/qow/archive/68/>.
     process.waitFor();
     // some browsers (mozilla, firefox) return 1 if you attempt to
     // open a url and an instance of that browser is already running
     // not clear why because the call is succeeding, ie the browser
     // opens the url.
     // If we don't say 1 is also a success, we get two browser
     // windows or tabs opened to the url.
     //
     // We could make this check smarter in the future if we run
     // into problems. the winBrowser object could handle the
     // check to make it browser specific.
     int exitValue = process.exitValue();
     success = exitValue == 0 || exitValue == 1;
   }
   // Runtimes may throw InterruptedException
   // want to catch every possible exception and wrap it
   catch (Exception e) {
     throw new BrowserLaunchingExecutionException(e);
   }
   return success;
 }
コード例 #3
0
 /**
  * Opens a url using a specific browser.
  *
  * <p>If the specified browser is not available, the method will fall through to calling the
  * default openUrl method.
  *
  * @param browser String
  * @param urlString String
  * @throws UnsupportedOperatingSystemException
  * @throws BrowserLaunchingExecutionException
  * @throws BrowserLaunchingInitializingException
  */
 public void openUrl(String browser, String urlString)
     throws UnsupportedOperatingSystemException, BrowserLaunchingExecutionException,
         BrowserLaunchingInitializingException {
   if (IBrowserLaunching.BROWSER_DEFAULT.equals(browser) || browser == null) {
     logger.info("default or null browser target; falling through to non-targetted openUrl");
     openUrl(urlString);
   } else {
     Map browserMap = getBrowserMap();
     WindowsBrowser winBrowser = (WindowsBrowser) browserMap.get(browser);
     if (winBrowser == null) {
       logger.info("the available browsers list does not contain: " + browser);
       logger.info("falling through to non-targetted openUrl");
       openUrl(urlString);
     } else {
       String protocol = null;
       try {
         protocol = getProtocol(urlString);
       } catch (MalformedURLException malrulex) {
         throw new BrowserLaunchingExecutionException(malrulex);
       }
       boolean successfullLaunch = openUrlWithBrowser(winBrowser, protocol, urlString);
       if (!successfullLaunch) {
         logger.debug("falling through to non-targetted openUrl");
         openUrl(urlString);
       }
     }
   }
 }
コード例 #4
0
 /**
  * Initializes the browser launcher from the windows config file. It initializes the browsers to
  * check list and the command line args to use for version of windows referenced by the
  * windowsKey.
  *
  * @see windowsKey
  * @throws BrowserLaunchingInitializingException
  */
 public void initialize() throws BrowserLaunchingInitializingException {
   try {
     URL configUrl = getClass().getResource(CONFIGFILE_WINDOWS);
     if (configUrl == null) {
       throw new BrowserLaunchingInitializingException(
           "unable to find config file: " + CONFIGFILE_WINDOWS);
     }
     Properties configProps = new Properties();
     configProps.load(configUrl.openStream());
     // get sep char
     String sepChar = configProps.getProperty(PROP_KEY_DELIMITER);
     // load different types of browsers
     Iterator keysIter = configProps.keySet().iterator();
     while (keysIter.hasNext()) {
       String key = (String) keysIter.next();
       if (key.startsWith(PROP_KEY_BROWSER_PREFIX)) {
         WindowsBrowser winBrowser = new WindowsBrowser(sepChar, configProps.getProperty(key));
         browsersToCheck.add(winBrowser);
       }
     }
     // load the type of windows based on the windows key
     String windowsConfigStr = configProps.getProperty(windowsKey, null);
     if (windowsConfigStr == null) {
       throw new BrowserLaunchingInitializingException(windowsKey + " is not a valid property");
     }
     String[] winConfigItems = windowsConfigStr.split(sepChar);
     commandsDefaultBrowser = winConfigItems[0];
     commandsTargettedBrowser = winConfigItems[1];
     Boolean boolVal = new Boolean(winConfigItems[2]);
     useRegistry = boolVal.booleanValue();
     // check for override of useRegistry from system prop
     // need to explicitly check BOTH values to filter out
     // invalid prop values
     String propValue =
         System.getProperty(IBrowserLaunching.WINDOWS_BROWSER_DISC_POLICY_PROPERTY, null);
     if (IBrowserLaunching.WINDOWS_BROWSER_DISC_POLICY_DISK.equals(propValue)) {
       useRegistry = false;
     } else if (IBrowserLaunching.WINDOWS_BROWSER_DISC_POLICY_REGISTRY.equals(propValue)) {
       useRegistry = true;
     }
     if (logger.isDebugEnabled()) {
       logger.debug(
           "Browser discovery policy property value=" + (propValue == null ? "null" : propValue));
       logger.debug("useRegistry=" + Boolean.toString(useRegistry));
     }
     // get info for checking Program Files folder
     programFilesFolderTemplate = configProps.getProperty("program.files.template", null);
     driveLetters = configProps.getProperty("drive.letters", null);
     // set brwosersToCheck to a non-modifiable list
     browsersToCheck = Collections.unmodifiableList(browsersToCheck);
   } catch (IOException ioex) {
     throw new BrowserLaunchingInitializingException(ioex);
   }
 }
コード例 #5
0
 /**
  * Use program files folder template from properties file and the list of drive letters from that
  * properties file
  *
  * @return File
  */
 private File getProgramFilesPath() {
   File progFilesPath = null;
   if (driveLetters != null && programFilesFolderTemplate != null) {
     String[] drives = driveLetters.split(";");
     for (int idx = 0; idx < drives.length && progFilesPath == null; idx++) {
       String path = MessageFormat.format(programFilesFolderTemplate, new Object[] {drives[idx]});
       File pfPath = new File(path);
       logger.debug(path);
       logger.debug(pfPath.getPath());
       if (pfPath.exists()) {
         progFilesPath = pfPath;
       }
     }
   }
   return progFilesPath;
 }
コード例 #6
0
 /**
  * Accesses the Windows registry to look for browser exes. The browsers search for are in the
  * browsersToCheck list. The returned map will use display names and exe names as keys to the
  * {@link WindowsBrowser WindowsBrowser} objects.
  *
  * @param browsersToCheck List
  * @return Map
  */
 private Map getAvailableBrowsers(List tempBrowsersToCheck) {
   logger.debug("finding available browsers using registry");
   logger.debug("browsers to check: " + tempBrowsersToCheck);
   Map browsersAvailable = new TreeMap(String.CASE_INSENSITIVE_ORDER);
   try {
     // create map of exe names to win browser objects
     Map exesToBrowserObjs = getExeNamesToBrowsers(tempBrowsersToCheck);
     // access and look in registry
     Regor regor = new Regor();
     String subKeyName = "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths";
     int key = regor.openKey(Regor.HKEY_LOCAL_MACHINE, subKeyName);
     if (key > -1) {
       List keys = regor.listKeys(key);
       Collections.sort(keys, String.CASE_INSENSITIVE_ORDER);
       Iterator keysIter = exesToBrowserObjs.keySet().iterator();
       while (keysIter.hasNext()) {
         String exeKey = (String) keysIter.next();
         int index = Collections.binarySearch(keys, exeKey, String.CASE_INSENSITIVE_ORDER);
         if (index >= 0) {
           WindowsBrowser winBrowser =
               getBrowserFromRegistryEntry(
                   regor, key, (String) keys.get(index), exeKey, exesToBrowserObjs);
           if (winBrowser != null) {
             if (logger.isDebugEnabled()) {
               logger.debug(
                   "Adding browser " + winBrowser.getBrowserDisplayName() + " to available list.");
               logger.debug(winBrowser.getPathToExe());
             }
             // adding display and exe for backward compatibility and
             // ease of use if someone passes in the name of an exe
             browsersAvailable.put(winBrowser.getBrowserDisplayName(), winBrowser);
             browsersAvailable.put(winBrowser.getBrowserApplicationName(), winBrowser);
             tempBrowsersToCheck.remove(winBrowser);
           }
         }
       }
     }
   } catch (RegistryErrorException ex) {
     logger.error("problem accessing registry", ex);
   }
   return browsersAvailable;
 }
コード例 #7
0
 /**
  * Checks that the windows key is valid.
  *
  * @param logger AbstractLogger
  * @param windowsKey String
  */
 public WindowsBrowserLaunching(AbstractLogger logger, String windowsKey) {
   if (windowsKey == null) {
     throw new IllegalArgumentException("windowsKey cannot be null");
   }
   if (Arrays.binarySearch(WIN_KEYS, windowsKey) < 0) {
     throw new IllegalArgumentException(windowsKey + " is invalid");
   }
   this.logger = logger;
   this.windowsKey = windowsKey;
   logger.info(windowsKey);
 }
コード例 #8
0
 /**
  * Opens a url using the default browser.
  *
  * @param urlString String
  * @throws UnsupportedOperatingSystemException
  * @throws BrowserLaunchingExecutionException
  * @throws BrowserLaunchingInitializingException
  */
 public void openUrl(String urlString)
     throws UnsupportedOperatingSystemException, BrowserLaunchingExecutionException,
         BrowserLaunchingInitializingException {
   try {
     logger.info(urlString);
     String protocol = getProtocol(urlString);
     logger.info(protocol);
     // try the system prop first
     boolean successfullSystemPropLaunch = false;
     String browserName = System.getProperty(IBrowserLaunching.BROWSER_SYSTEM_PROPERTY, null);
     if (browserName != null) {
       Map browserMap = getBrowserMap();
       WindowsBrowser winBrowser = (WindowsBrowser) browserMap.get(browserName);
       if (winBrowser != null) {
         logger.debug("using browser from system property");
         successfullSystemPropLaunch = openUrlWithBrowser(winBrowser, protocol, urlString);
       }
     }
     if (!successfullSystemPropLaunch) {
       String[] args = getCommandArgs(protocol, urlString);
       if (logger.isDebugEnabled()) {
         logger.debug(getArrayAsString(args));
       }
       Process process = Runtime.getRuntime().exec(args);
       // This avoids a memory leak on some versions of Java on Windows.
       // That's hinted at in <http://developer.java.sun.com/developer/qow/archive/68/>.
       process.waitFor();
       process.exitValue();
     }
   } catch (Exception e) {
     logger.error("fatal exception", e);
     throw new BrowserLaunchingExecutionException(e);
   }
 }
コード例 #9
0
 /**
  * Secondary method for browser discovery.
  *
  * <p>Uses IE to get the path to the Program Files directory; then gets a list of the sub dirs and
  * checks them against the remaining browsers.
  *
  * @param iePath String
  * @param browsersAvailable Map
  * @param tmpBrowsersToCheck List
  */
 private Map processFilePathsForBrowsers(List tmpBrowsersToCheck) {
   logger.debug("finding available browsers in program files path");
   logger.debug("browsers to check: " + tmpBrowsersToCheck);
   Map browsersAvailable = new HashMap();
   File progFilesPath = getProgramFilesPath();
   if (progFilesPath != null) {
     logger.debug("program files path: " + progFilesPath.getPath());
     File[] subDirs = progFilesPath.listFiles(new DirFileFilter());
     int subDirsCnt = subDirs != null ? subDirs.length : 0;
     // create and populate map of dir names to win browser objects
     Iterator iter = tmpBrowsersToCheck.iterator();
     Map dirNameToBrowser = new HashMap();
     while (iter.hasNext()) {
       WindowsBrowser wBrowser = (WindowsBrowser) iter.next();
       dirNameToBrowser.put(wBrowser.getSubDirName(), wBrowser);
     }
     // iterate over subdirs and compare to map entries
     for (int idx = 0; idx < subDirsCnt && !tmpBrowsersToCheck.isEmpty(); idx++) {
       if (dirNameToBrowser.containsKey(subDirs[idx].getName())) {
         WindowsBrowser wBrowser = (WindowsBrowser) dirNameToBrowser.get(subDirs[idx].getName());
         // need to search folder and sub-folders for exe to find
         // the full path
         String exeName = wBrowser.getBrowserApplicationName() + ".exe";
         File fullPathToExe = findExeFilePath(subDirs[idx], exeName);
         if (fullPathToExe != null) {
           logger.debug(
               "Adding browser " + wBrowser.getBrowserDisplayName() + " to available list.");
           wBrowser.setPathToExe(fullPathToExe.getPath());
           logger.debug(wBrowser.getPathToExe());
           // adding display and exe for backward compatibility and
           // ease of use if someone passes in the name of an exe
           browsersAvailable.put(wBrowser.getBrowserDisplayName(), wBrowser);
           browsersAvailable.put(wBrowser.getBrowserApplicationName(), wBrowser);
           tmpBrowsersToCheck.remove(wBrowser);
         }
       }
     }
   }
   return browsersAvailable;
 }
コード例 #10
0
  /**
   * Returns true if the browser is available, ie mdfind command finds it.
   *
   * @param logger AbstractLogger
   * @return boolean
   */
  public boolean isBrowserAvailable(StandardUnixBrowser browser, AbstractLogger logger) {
    boolean isAvailable = false;
    try {
      Process process =
          Runtime.getRuntime().exec(new String[] {"mdfind", browser.getBrowserApplicationName()});
      InputStream errStream = process.getErrorStream();
      InputStream inStream = process.getInputStream();
      BufferedReader errIn = new BufferedReader(new InputStreamReader(errStream));
      BufferedReader in = new BufferedReader(new InputStreamReader(inStream));

      String temp;
      StringBuffer whichOutput = new StringBuffer();
      while ((temp = in.readLine()) != null) {
        // Searching with spotlight (mdfind) will find more than just the app sometimes
        if (temp.indexOf(browser.getBrowserApplicationName()) > -1) {
          whichOutput.append(temp);
        }
      }

      StringBuffer whichErrOutput = new StringBuffer();
      while ((temp = errIn.readLine()) != null) {
        whichErrOutput.append(temp);
      }

      in.close();
      errIn.close();
      if (whichOutput.length() > 0) {
        logger.debug(whichOutput.toString());
        // very weak test but should be enough since the Open -a applicationname works very well
        isAvailable = true;
      }
      if (whichErrOutput.length() > 0) {
        logger.debug(whichErrOutput.toString());
      }
    } catch (IOException ex) {
      logger.error("io error executing which command", ex);
    }
    return isAvailable;
  }