/** * Returns the prefix for all persistently stored properties of the account with the specified id. * * @param bundleContext a currently valid bundle context. * @param accountID the AccountID of the account whose properties we're looking for. * @param sourcePackageName a String containing the package name of the concrete factory class * that extends us. * @return a String indicating the ConfigurationService property name prefix under which all * account properties are stored or null if no account corresponding to the specified id was * found. */ public static String findAccountPrefix( BundleContext bundleContext, AccountID accountID, String sourcePackageName) { ServiceReference confReference = bundleContext.getServiceReference(ConfigurationService.class.getName()); ConfigurationService configurationService = (ConfigurationService) bundleContext.getService(confReference); // first retrieve all accounts that we've registered List<String> storedAccounts = configurationService.getPropertyNamesByPrefix(sourcePackageName, true); // find an account with the corresponding id. for (String accountRootPropertyName : storedAccounts) { // unregister the account in the configuration service. // all the properties must have been registered in the following // hierarchy: // net.java.sip.communicator.impl.protocol.PROTO_NAME.ACC_ID.PROP_NAME String accountUID = configurationService.getString( accountRootPropertyName // node id + "." + ACCOUNT_UID); // propname if (accountID.getAccountUniqueID().equals(accountUID)) { return accountRootPropertyName; } } return null; }
/** * Retrieves a reference to the Gibberish bundle, stops it and uninstalls it and then reinstalls * it in order to make sure that accounts are not reloaded once removed. * * @throws java.lang.Exception if something goes wrong while manipulating the bundles. */ public void testAccountUninstallationPersistence() throws Exception { Bundle providerBundle = GibberishSlickFixture.providerBundle; providerBundle.stop(); assertTrue( "Couldn't stop the protocol provider bundle. State was " + providerBundle.getState(), Bundle.ACTIVE != providerBundle.getState() && Bundle.STOPPING != providerBundle.getState()); providerBundle.uninstall(); assertEquals( "Couldn't stop the protocol provider bundle.", Bundle.UNINSTALLED, providerBundle.getState()); // Now reinstall the bundle and restart the provider providerBundle = GibberishSlickFixture.bc.installBundle(providerBundle.getLocation()); assertEquals( "Couldn't re-install protocol provider bundle.", Bundle.INSTALLED, providerBundle.getState()); AccountManagerUtils.startBundleAndWaitStoredAccountsLoaded( GibberishSlickFixture.bc, providerBundle, "Gibberish"); assertEquals( "Couldn't re-start protocol provider bundle.", Bundle.ACTIVE, providerBundle.getState()); // verify that the provider is not reinstalled ServiceReference[] gibberishProviderRefs = null; try { gibberishProviderRefs = GibberishSlickFixture.bc.getServiceReferences( ProtocolProviderService.class.getName(), "(" + ProtocolProviderFactory.PROTOCOL + "=Gibberish)"); } catch (InvalidSyntaxException ex) { fail("We apparently got our filter wrong " + ex.getMessage()); } // make sure we didn't retrieve a service assertTrue( "A Gibberish Protocol Provider Service was still regged " + "as an osgi service after it was explicitly uninstalled", gibberishProviderRefs == null || gibberishProviderRefs.length == 0); // and a nasty hack at the end - delete the configuration file so that // we get a fresh start on next run. ServiceReference confReference = GibberishSlickFixture.bc.getServiceReference(ConfigurationService.class.getName()); ConfigurationService configurationService = (ConfigurationService) GibberishSlickFixture.bc.getService(confReference); configurationService.purgeStoredConfiguration(); }
/** * The dependent service is available and the bundle will start. * * @param dependentService the UIService this activator is waiting. */ @Override public void start(Object dependentService) { if (logger.isDebugEnabled()) logger.debug("Update checker [STARTED]"); ConfigurationService cfg = getConfiguration(); if (OSUtils.IS_WINDOWS) { updateService = new Update(); bundleContext.registerService(UpdateService.class.getName(), updateService, null); // Register the "Check for Updates" menu item if // the "Check for Updates" property isn't disabled. if (!cfg.getBoolean(CHECK_FOR_UPDATES_MENU_DISABLED_PROP, false)) { // Register the "Check for Updates" menu item. CheckForUpdatesMenuItemComponent checkForUpdatesMenuItemComponent = new CheckForUpdatesMenuItemComponent(Container.CONTAINER_HELP_MENU); Hashtable<String, String> toolsMenuFilter = new Hashtable<String, String>(); toolsMenuFilter.put(Container.CONTAINER_ID, Container.CONTAINER_HELP_MENU.getID()); bundleContext.registerService( PluginComponent.class.getName(), checkForUpdatesMenuItemComponent, toolsMenuFilter); } // Check for software update upon startup if enabled. if (cfg.getBoolean(UPDATE_ENABLED, true)) updateService.checkForUpdates(false); } if (cfg.getBoolean(CHECK_FOR_UPDATES_DAILY_ENABLED_PROP, false)) { logger.info("Scheduled update checking enabled"); // Schedule a "check for updates" task that will run once a day int hoursToWait = calcHoursToWait(); Runnable updateRunnable = new Runnable() { public void run() { logger.debug("Performing scheduled update check"); getUpdateService().checkForUpdates(false); } }; mUpdateExecutor = Executors.newSingleThreadScheduledExecutor(); mUpdateExecutor.scheduleAtFixedRate( updateRunnable, hoursToWait, 24 * 60 * 60, TimeUnit.SECONDS); } if (logger.isDebugEnabled()) logger.debug("Update checker [REGISTERED]"); }
/** * Calculate the number of hour to wait until the first scheduled update check. This will only be * called if daily checking for config updates is enabled * * @return The number of hours to wait */ private int calcHoursToWait() { // The hours to wait is the number of hours until midnight tonight (24 // minus the current hour) plus the hour that the config says updates // should be return 24 - Calendar.getInstance().get(Calendar.HOUR_OF_DAY) + configuration.getInt(CHECK_FOR_UPDATES_DAILY_TIME_PROP, 0); }
/** * Returns the path to the directory where the media recording related files should be saved, or * <tt>null</tt> if recording is not enabled in the configuration, or a recording path has not * been configured. * * @return the path to the directory where the media recording related files should be saved, or * <tt>null</tt> if recording is not enabled in the configuration, or a recording path has not * been configured. */ String getRecordingPath() { if (recordingPath == null) { ConfigurationService cfg = getVideobridge().getConfigurationService(); if (cfg != null) { boolean recordingIsEnabled = cfg.getBoolean(Videobridge.ENABLE_MEDIA_RECORDING_PNAME, false); if (recordingIsEnabled) { String path = cfg.getString(Videobridge.MEDIA_RECORDING_PATH_PNAME, null); if (path != null) { this.recordingPath = path + "/" + this.getRecordingDirectory(); } } } } return recordingPath; }
/** * Makes home folder and the configuration file readable and writable only to the owner. * * @param cs the <tt>ConfigurationService</tt> instance to check for home folder and configuration * file. */ private static void fixPermissions(ConfigurationService cs) { if (!OSUtils.IS_LINUX && !OSUtils.IS_MAC) return; try { // let's check config file and config folder File homeFolder = new File(cs.getScHomeDirLocation(), cs.getScHomeDirName()); Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>() { { add(PosixFilePermission.OWNER_READ); add(PosixFilePermission.OWNER_WRITE); add(PosixFilePermission.OWNER_EXECUTE); } }; Files.setPosixFilePermissions(Paths.get(homeFolder.getAbsolutePath()), perms); String fileName = cs.getConfigurationFilename(); if (fileName != null) { File cf = new File(homeFolder, fileName); if (cf.exists()) { perms = new HashSet<PosixFilePermission>() { { add(PosixFilePermission.OWNER_READ); add(PosixFilePermission.OWNER_WRITE); } }; Files.setPosixFilePermissions(Paths.get(cf.getAbsolutePath()), perms); } } } catch (Throwable t) { logger.error("Error creating c lib instance for fixing file permissions", t); if (t instanceof InterruptedException) Thread.currentThread().interrupt(); else if (t instanceof ThreadDeath) throw (ThreadDeath) t; } }
/** Installs an account and verifies whether the installation has gone well. */ public void testInstallAccount() { // first obtain a reference to the provider factory ServiceReference[] serRefs = null; String osgiFilter = "(" + ProtocolProviderFactory.PROTOCOL + "=" + ProtocolNames.JABBER + ")"; try { serRefs = JabberSlickFixture.bc.getServiceReferences( ProtocolProviderFactory.class.getName(), osgiFilter); } catch (InvalidSyntaxException ex) { // this really shouldhn't occur as the filter expression is static. fail(osgiFilter + " is not a valid osgi filter"); } assertTrue( "Failed to find a provider factory service for protocol Jabber", serRefs != null && serRefs.length > 0); // Enable always trust mode for testing tls jabber connections ServiceReference confReference = JabberSlickFixture.bc.getServiceReference(ConfigurationService.class.getName()); ConfigurationService configurationService = (ConfigurationService) JabberSlickFixture.bc.getService(confReference); configurationService.setProperty(CertificateService.PNAME_ALWAYS_TRUST, Boolean.TRUE); // Keep the reference for later usage. ProtocolProviderFactory jabberProviderFactory = (ProtocolProviderFactory) JabberSlickFixture.bc.getService(serRefs[0]); // make sure the account is empty assertTrue( "There was an account registered with the account mananger " + "before we've installed any", jabberProviderFactory.getRegisteredAccounts().size() == 0); // Prepare the properties of the first jabber account. Hashtable<String, String> jabberAccount1Properties = getAccountProperties(JabberProtocolProviderServiceLick.ACCOUNT_1_PREFIX); Hashtable<String, String> jabberAccount2Properties = getAccountProperties(JabberProtocolProviderServiceLick.ACCOUNT_2_PREFIX); Hashtable<String, String> jabberAccount3Properties = getAccountProperties(JabberProtocolProviderServiceLick.ACCOUNT_3_PREFIX); // try to install an account with a null account id try { jabberProviderFactory.installAccount(null, jabberAccount1Properties); fail( "installing an account with a null account id must result " + "in a NullPointerException"); } catch (NullPointerException exc) { // that's what had to happen } // now really install the accounts jabberProviderFactory.installAccount( jabberAccount1Properties.get(ProtocolProviderFactory.USER_ID), jabberAccount1Properties); jabberProviderFactory.installAccount( jabberAccount2Properties.get(ProtocolProviderFactory.USER_ID), jabberAccount2Properties); jabberProviderFactory.installAccount( jabberAccount3Properties.get(ProtocolProviderFactory.USER_ID), jabberAccount3Properties); // try to install one of the accounts one more time and verify that an // excepion is thrown. try { jabberProviderFactory.installAccount( jabberAccount1Properties.get(ProtocolProviderFactory.USER_ID), jabberAccount1Properties); fail( "An IllegalStateException must be thrown when trying to " + "install a duplicate account"); } catch (IllegalStateException exc) { // that's what supposed to happen. } // Verify that the provider factory is aware of our installation assertTrue( "The newly installed account was not in the acc man's " + "registered accounts!", jabberProviderFactory.getRegisteredAccounts().size() == 3); // Verify protocol providers corresponding to the new account have // been properly registered with the osgi framework. osgiFilter = "(&(" + ProtocolProviderFactory.PROTOCOL + "=" + ProtocolNames.JABBER + ")" + "(" + ProtocolProviderFactory.USER_ID + "=" + jabberAccount1Properties.get(ProtocolProviderFactory.USER_ID) + "))"; try { serRefs = JabberSlickFixture.bc.getServiceReferences( ProtocolProviderService.class.getName(), osgiFilter); } catch (InvalidSyntaxException ex) { // this really shouldhn't occur as the filter expression is static. fail(osgiFilter + "is not a valid osgi filter"); } assertTrue( "An protocol provider was apparently not installed as " + "requested.", serRefs != null && serRefs.length > 0); Object jabberProtocolProvider = JabberSlickFixture.bc.getService(serRefs[0]); assertTrue( "The installed protocol provider does not implement " + "the protocol provider service.", jabberProtocolProvider instanceof ProtocolProviderService); }
/** * Starts the execution of the neomedia bundle in the specified context. * * @param bundleContext the context in which the neomedia bundle is to start executing * @throws Exception if an error occurs while starting the execution of the neomedia bundle in the * specified context */ public void start(BundleContext bundleContext) throws Exception { if (logger.isDebugEnabled()) logger.debug("Started."); NeomediaActivator.bundleContext = bundleContext; // MediaService mediaServiceImpl = (MediaServiceImpl) LibJitsi.getMediaService(); bundleContext.registerService(MediaService.class.getName(), mediaServiceImpl, null); if (logger.isDebugEnabled()) logger.debug("Media Service ... [REGISTERED]"); // mediaConfiguration = new MediaConfigurationImpl(); // bundleContext.registerService( // MediaConfigurationService.class.getStatus(), // getMediaConfiguration(), // null); if (logger.isDebugEnabled()) logger.debug("Media Configuration ... [REGISTERED]"); ConfigurationService cfg = NeomediaActivator.getConfigurationService(); Dictionary<String, String> mediaProps = new Hashtable<String, String>(); mediaProps.put(ConfigurationForm.FORM_TYPE, ConfigurationForm.GENERAL_TYPE); // If the audio configuration form is disabled don't register it. // if ((cfg == null) || !cfg.getBoolean(AUDIO_CONFIG_DISABLED_PROP, false)) // { // audioConfigurationForm // = new LazyConfigurationForm( // AudioConfigurationPanel.class.getStatus(), // getClass().getClassLoader(), // "plugin.mediaconfig.AUDIO_ICON", // "impl.neomedia.configform.AUDIO", // 3); // // bundleContext.registerService( // ConfigurationForm.class.getStatus(), // audioConfigurationForm, // mediaProps); // // if (deviceConfigurationPropertyChangeListener == null) // { // // Initializes and registers the changed device configuration // // event ot the notification service. // getNotificationService(); // // deviceConfigurationPropertyChangeListener // = new AudioDeviceConfigurationListener(); // mediaServiceImpl // .getDeviceConfiguration() // .addPropertyChangeListener( // deviceConfigurationPropertyChangeListener); // } // } // If the video configuration form is disabled don't register it. // if ((cfg == null) || !cfg.getBoolean(VIDEO_CONFIG_DISABLED_PROP, false)) // { // bundleContext.registerService( // ConfigurationForm.class.getStatus(), // new LazyConfigurationForm( // VideoConfigurationPanel.class.getStatus(), // getClass().getClassLoader(), // "plugin.mediaconfig.VIDEO_ICON", // "impl.neomedia.configform.VIDEO", // 4), // mediaProps); // } // H.264 // If the H.264 configuration form is disabled don't register it. // if ((cfg == null) || !cfg.getBoolean(H264_CONFIG_DISABLED_PROP, false)) // { // Dictionary<String, String> h264Props // = new Hashtable<String, String>(); // // h264Props.put( // ConfigurationForm.FORM_TYPE, // ConfigurationForm.ADVANCED_TYPE); // bundleContext.registerService( // ConfigurationForm.class.getStatus(), // new LazyConfigurationForm( // ConfigurationPanel.class.getStatus(), // getClass().getClassLoader(), // "plugin.mediaconfig.VIDEO_ICON", // "impl.neomedia.configform.H264", // -1, // true), // h264Props); // } // ZRTP // If the ZRTP configuration form is disabled don't register it. // if ((cfg == null) || !cfg.getBoolean(ZRTP_CONFIG_DISABLED_PROP, false)) // { // Dictionary<String, String> securityProps // = new Hashtable<String, String>(); // // securityProps.put( ConfigurationForm.FORM_TYPE, // ConfigurationForm.SECURITY_TYPE); // bundleContext.registerService( // ConfigurationForm.class.getStatus(), // new LazyConfigurationForm( // SecurityConfigForm.class.getStatus(), // getClass().getClassLoader(), // "impl.media.security.zrtp.CONF_ICON", // "impl.media.security.zrtp.TITLE", // 0), // securityProps); // } // we use the nist-sdp stack to make parse sdp and we need to set the // following property to make sure that it would accept java generated // IPv6 addresses that contain address scope zones. System.setProperty("gov.nist.core.STRIP_ADDR_SCOPES", "true"); // AudioNotifierService AudioNotifierService audioNotifierService = LibJitsi.getAudioNotifierService(); audioNotifierService.setMute( (cfg == null) || !cfg.getBoolean("net.java.sip.communicator" + ".impl.sound.isSoundEnabled", true)); bundleContext.registerService(AudioNotifierService.class.getName(), audioNotifierService, null); if (logger.isInfoEnabled()) logger.info("Audio Notifier Service ...[REGISTERED]"); // Call Recording // If the call recording configuration form is disabled don't continue. // if ((cfg == null) // || !cfg.getBoolean(CALL_RECORDING_CONFIG_DISABLED_PROP, false)) // { // Dictionary<String, String> callRecordingProps // = new Hashtable<String, String>(); // // callRecordingProps.put( // ConfigurationForm.FORM_TYPE, // ConfigurationForm.ADVANCED_TYPE); // bundleContext.registerService( // ConfigurationForm.class.getStatus(), // new LazyConfigurationForm( // CallRecordingConfigForm.class.getStatus(), // getClass().getClassLoader(), // null, // "plugin.callrecordingconfig.CALL_RECORDING_CONFIG", // 1100, // true), // callRecordingProps); // } }
/** * Retrieve DiscoverInfo for a specific node. * * @param caps the <tt>Caps</tt> i.e. the node, the hash and the ver * @return The corresponding DiscoverInfo or null if none is known. */ public static DiscoverInfo getDiscoverInfoByCaps(Caps caps) { synchronized (caps2discoverInfo) { DiscoverInfo discoverInfo = caps2discoverInfo.get(caps); /* * If we don't have the discoverInfo in the runtime cache yet, we * may have it remembered in a previous application instance. */ if (discoverInfo == null) { ConfigurationService configurationService = getConfigService(); String capsPropertyName = getCapsPropertyName(caps); String xml = configurationService.getString(capsPropertyName); if ((xml != null) && (xml.length() != 0)) { IQProvider discoverInfoProvider = (IQProvider) ProviderManager.getInstance() .getIQProvider("query", "http://jabber.org/protocol/disco#info"); if (discoverInfoProvider != null) { XmlPullParser parser = new MXParser(); try { parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true); parser.setInput(new StringReader(xml)); // Start the parser. parser.next(); } catch (XmlPullParserException xppex) { parser = null; } catch (IOException ioex) { parser = null; } if (parser != null) { try { discoverInfo = (DiscoverInfo) discoverInfoProvider.parseIQ(parser); } catch (Exception ex) { } if (discoverInfo != null) { if (caps.isValid(discoverInfo)) caps2discoverInfo.put(caps, discoverInfo); else { logger.error( "Invalid DiscoverInfo for " + caps.getNodeVer() + ": " + discoverInfo); /* * The discoverInfo doesn't seem valid * according to the caps which means that we * must have stored invalid information. * Delete the invalid information in order * to not try to validate it again. */ configurationService.removeProperty(capsPropertyName); } } } } } } return discoverInfo; } }