plugins/org.eclipse.jst.common.project.facet.core/src/org/eclipse/jst/common/project/facet/core/libprov/LibraryInstallDelegate.java - webtools-common/webtools.common - Git at Google

 /******************************************************************************
  * Copyright (c) 2010 Oracle
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
  *    Konstantin Komissarchik - initial implementation and ongoing maintenance
  ******************************************************************************/

 package org.eclipse.jst.common.project.facet.core.libprov;

 import static org.eclipse.jst.common.project.facet.core.internal.FacetedProjectFrameworkJavaPlugin.createErrorStatus;
 import static org.eclipse.jst.common.project.facet.core.internal.FacetedProjectFrameworkJavaPlugin.log;
 import static org.eclipse.wst.common.project.facet.core.util.internal.ProgressMonitorUtil.beginTask;
 import static org.eclipse.wst.common.project.facet.core.util.internal.ProgressMonitorUtil.done;
 import static org.eclipse.wst.common.project.facet.core.util.internal.ProgressMonitorUtil.submon;
 import static org.eclipse.wst.common.project.facet.core.util.internal.ProgressMonitorUtil.worked;
 import static org.eclipse.wst.common.project.facet.core.util.internal.MiscUtil.equal;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.jst.common.project.facet.core.libprov.internal.LibraryProvider;
 import org.eclipse.jst.common.project.facet.core.libprov.internal.LibraryProviderFrameworkImpl;
 import org.eclipse.jst.common.project.facet.core.libprov.internal.PropertiesHost;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.wst.common.project.facet.core.IFacetedProject;
 import org.eclipse.wst.common.project.facet.core.IFacetedProjectBase;
 import org.eclipse.wst.common.project.facet.core.IFacetedProjectWorkingCopy;
 import org.eclipse.wst.common.project.facet.core.IProjectFacet;
 import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectEvent;
 import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectListener;
 import org.eclipse.wst.common.project.facet.core.util.internal.CollectionsUtil;

 /**
  * Used for configuring and then installing a library via the Library Provider Framework.
  * Instance of this class would typically be embedded in facet action config objects and then
  * executed during the execution of those actions. Can also be used stand-alone when it is
  * necessary to change libraries outside facet lifecycle actions.
  *
  * @author <a href="mailto:konstantin.komissarchik@oracle.com">Konstantin Komissarchik</a>
  * @since 1.4
  */

 public final class LibraryInstallDelegate

     extends PropertiesHost

 {
     private static final String CLASS_NAME = LibraryInstallDelegate.class.getName();

     /**
      * The property corresponding to the list of available providers.
      */

     public static final String PROP_AVAILABLE_PROVIDERS
         = CLASS_NAME + ".AVAILABLE_PROVIDERS"; //$NON-NLS-1$

     /**
      * The property corresponding to the currently-selected provider.
      */

     public static final String PROP_SELECTED_PROVIDER
         = CLASS_NAME + ".SELECTED_PROVIDER"; //$NON-NLS-1$

     private final IFacetedProjectBase fproj;
     private IProjectFacetVersion fv;
     private List<ILibraryProvider> providers;
     private List<ILibraryProvider> providersReadOnly;
     private ILibraryProvider selectedProvider;
     private boolean isDefaultSelection;
     private final Map<ILibraryProvider,LibraryProviderOperationConfig> configs;
     private final IPropertyChangeListener providerConfigListener;
     private LibraryUninstallDelegate uninstallDelegate = null;
     private Map<String,Object> customEnablementContextVariables;
     private final IFacetedProjectListener facetedProjectListener;

     /**
      * Constructs a new library install delegate.
      *
      * @param fproj the faceted project (or a working copy)
      * @param fv the project facet that is requesting libraries
      * @param customEnablementContextVariables custom variables to add to the expression
      *   evaluation context for enablement expressions or <code>null</code> for none
      * @see #setEnablementContextVariable(String, Object)
      */

     public LibraryInstallDelegate( final IFacetedProjectBase fproj,
                                    final IProjectFacetVersion fv,
                                    final Map<String,Object> customEnablementContextVariables )
     {
         this.fproj = fproj;
         this.fv = fv;
         this.providers = Collections.emptyList();
         this.providersReadOnly = Collections.emptyList();
         this.selectedProvider = null;
         this.isDefaultSelection = true;
         this.configs = new HashMap<ILibraryProvider,LibraryProviderOperationConfig>();
         this.customEnablementContextVariables = new HashMap<String,Object>();

         if( customEnablementContextVariables != null )
         {
             this.customEnablementContextVariables.putAll( customEnablementContextVariables );
         }

         this.providerConfigListener = new IPropertyChangeListener()
         {
             public void propertyChanged( final String property,
                                          final Object oldValue,
                                          final Object newValue )
             {
                 notifyListeners( property, oldValue, newValue );
             }
         };

         this.facetedProjectListener = new IFacetedProjectListener()
         {
             public void handleEvent( final IFacetedProjectEvent event )
             {
                 refresh();
             }
         };

         getFacetedProject().addListener( this.facetedProjectListener, IFacetedProjectEvent.Type.PROJECT_MODIFIED );

         reset();
     }

     /**
      * Constructs a new library install delegate.
      *
      * @param fproj the faceted project (or a working copy)
      * @param fv the project facet that is requesting libraries
      */

     public LibraryInstallDelegate( final IFacetedProjectBase fproj,
                                    final IProjectFacetVersion fv )
     {
         this( fproj, fv, null );
     }

     /**
      * Returns the faceted project that this install delegate was configured to use. Can be a working
      * copy.
      *
      * @return the faceted project that this install delegate was configured to use
      */

     public IFacetedProjectBase getFacetedProject()
     {
         return this.fproj;
     }

     /**
      * Returns the project facet that made the request for libraries.
      *
      * @return the project facet that made the request for libraries
      */

     public synchronized IProjectFacet getProjectFacet()
     {
         return this.fv.getProjectFacet();
     }

     /**
      * Returns the project facet version that made the request for libraries.
      *
      * @return the project facet version that made the request for libraries
      */

     public synchronized IProjectFacetVersion getProjectFacetVersion()
     {
         return this.fv;
     }

     /**
      * Changes the project facet version of the requesting facet after the library install
      * delegate has been created.
      *
      * @param fv the project facet version
      */

     public synchronized void setProjectFacetVersion( final IProjectFacetVersion fv )
     {
         this.fv = fv;
         refresh();
     }

     /**
      * Returns the list of library providers that are currently available. The list is sorted
      * by library provider priority (highest priority first). To listen for changes to this
      * list use PROP_AVAILABLE_PROVIDERS.
      *
      * @return the list of library providers that are currently available
      */

     public synchronized List<ILibraryProvider> getLibraryProviders()
     {
         return this.providersReadOnly;
     }

     /**
      * Returns the library provider that is currently selected. To list for changes to this
      * property use PROP_SELECTED_PROVIDER.
      *
      * @return the library provider that is currently selected
      */

     public synchronized ILibraryProvider getLibraryProvider()
     {
         return this.selectedProvider;
     }

     /**
      * Sets the current library provider.
      *
      * @param provider the provider that should be selected
      */

     public synchronized void setLibraryProvider( final ILibraryProvider provider )
     {
         setLibraryProvider( provider, false, true );
     }

     private synchronized void setLibraryProvider( final ILibraryProvider provider,
                                                   final boolean isDefaultSelection,
                                                   final boolean notifyListeners )
     {
         if( ! this.providers.contains( provider ) &&
             ! ( this.providers.size() == 0 && provider == null ) )
         {
             throw new IllegalArgumentException();
         }

         if( ! equal( this.selectedProvider, provider ) )
         {
             final ILibraryProvider oldSelectedProvider = this.selectedProvider;

             this.selectedProvider = provider;
             this.isDefaultSelection = isDefaultSelection;

             final LibraryProviderOperationConfig config = this.configs.get( this.selectedProvider );

             if( config != null )
             {
                 config.reset();
             }

             if( notifyListeners )
             {
                 notifyListeners( PROP_SELECTED_PROVIDER, oldSelectedProvider, this.selectedProvider );
             }
         }
     }

     /**
      * Returns the install operation config of the currently-selected provider. This property's
      * lifecycle is bound to the current provider changes, so listen for changes using
      * PROP_SELECTED_PROVIDER.
      *
      * @return the install operation config of the currently-selected provider
      */

     public synchronized LibraryProviderOperationConfig getLibraryProviderOperationConfig()
     {
         if( this.selectedProvider == null )
         {
             return null;
         }
         else
         {
             return this.configs.get( this.selectedProvider );
         }
     }

     /**
      * Returns the install operation config for any of the available library providers.
      *
      * @param provider the library provider to look up install operation config
      * @return the install operation config for any of the available library providers
      */

     public synchronized LibraryProviderOperationConfig getLibraryProviderOperationConfig( final ILibraryProvider provider )
     {
         if( ! this.providers.contains( provider ) )
         {
             throw new IllegalArgumentException();
         }

         return this.configs.get( provider );
     }

     /**
      * Adds a custom variable to the expression evaluation context for enablement expressions
      * controlling activation of library providers. Setting the variable to <code>null</code>
      * has the effect of removing it. Calling this method will trigger a refresh of available
      * library providers.
      *
      * @param name the name of the variable
      * @param value the value of the variable
      */

     public synchronized void setEnablementContextVariable( final String name,
                                                            final Object value )
     {
         final Object currentValue = this.customEnablementContextVariables.get( name );

         if( ! equal( currentValue, value ) )
         {
             if( value == null )
             {
                 this.customEnablementContextVariables.remove( name );
             }
             else
             {
                 this.customEnablementContextVariables.put( name, value );
             }

             refresh();
         }
     }

     /**
      * Refreshes the list of available library providers and resets the current library provider
      * if the one currently selected is not in the available list any longer.
      */

     public synchronized void refresh()
     {
         final IProjectFacet f = getProjectFacet();
         final IProjectFacetVersion fv = getProjectFacetVersion();
         final IFacetedProjectBase fproj = getFacetedProject();

         final List<ILibraryProvider> oldProviders = this.providers;

         for( ILibraryProvider provider : oldProviders )
         {
             final LibraryProviderOperationConfig config = this.configs.remove( provider );

             if( config != null )
             {
                 config.removeListener( this.providerConfigListener );
                 config.dispose();
             }
         }

         final List<ILibraryProvider> newProviders = new ArrayList<ILibraryProvider>();

         for( ILibraryProvider provider : LibraryProviderFramework.getProviders() )
         {
             if( ! provider.isAbstract() && ! provider.isHidden()
                 && provider.isEnabledFor( fproj, fv, this.customEnablementContextVariables ) )
             {
                 newProviders.add( provider );
             }
         }

         final Comparator<ILibraryProvider> comp = CollectionsUtil.getInvertingComparator();
         Collections.sort( newProviders, comp );

         final IFacetedProject base;

         if( fproj instanceof IFacetedProject )
         {
             base = (IFacetedProject) fproj;
         }
         else
         {
             base = ( (IFacetedProjectWorkingCopy) fproj ).getFacetedProject();
         }

         if( base != null && base.hasProjectFacet( f ) )
         {
             // This code is here to take care of cases where framework injects a provider
             // that is not typically available for unknown and legacy usecases.

             final ILibraryProvider provider
                 = LibraryProviderFramework.getCurrentProvider( base.getProject(), f );

             if( provider == null )
             {
                 throw new RuntimeException();
             }

             if( ! newProviders.contains( provider ) )
             {
                 newProviders.add( provider );
             }
         }

         this.providers = newProviders;
         this.providersReadOnly = Collections.unmodifiableList( this.providers );

         for( ILibraryProvider provider : this.providers )
         {
             final LibraryProvider prov = (LibraryProvider) provider;
             final LibraryProviderOperationConfig config = prov.createInstallOperationConfig( this );
             config.addListener( this.providerConfigListener );
             this.configs.put( provider, config );
         }

         final ILibraryProvider oldSelectedProvider = this.selectedProvider;

         if( this.providers.size() > 0 )
         {
             if( this.selectedProvider == null || this.isDefaultSelection ||
                 ! this.providers.contains( this.selectedProvider ) )
             {
                 ILibraryProvider provider = LibraryProviderFrameworkImpl.get().getLastProviderUsed( fv );

                 if( provider == null || ! this.providers.contains( provider ) )
                 {
                     provider = this.providers.iterator().next();
                 }

                 setLibraryProvider( provider, true, false );
             }
         }
         else
         {
             setLibraryProvider( null, true, false );
         }

         notifyListeners( PROP_AVAILABLE_PROVIDERS, oldProviders, this.providersReadOnly );

         if( ! equal( oldSelectedProvider, this.selectedProvider ) )
         {
             notifyListeners( PROP_SELECTED_PROVIDER, oldSelectedProvider, this.selectedProvider );
         }
     }

     /**
      * Resets this install delegate to its initial state (prior to any user changes).
      */

     public synchronized void reset()
     {
         refresh();

         final IProjectFacet facet = this.fv.getProjectFacet();
         final IFacetedProject fpj;

         if( this.fproj instanceof IFacetedProject )
         {
             fpj = (IFacetedProject) this.fproj;
         }
         else
         {
             fpj = ( (IFacetedProjectWorkingCopy) this.fproj ).getFacetedProject();
         }

         ILibraryProvider provider = null;

         if( this.uninstallDelegate != null )
         {
         	this.uninstallDelegate.dispose();
         	this.uninstallDelegate = null;
         }

         if( fpj != null && fpj.hasProjectFacet( facet ) )
         {
             this.uninstallDelegate = new LibraryUninstallDelegate( fpj, this.fv );

             provider = LibraryProviderFramework.getCurrentProvider( fpj.getProject(), facet );

             if( provider == null )
             {
                 throw new RuntimeException();
             }
         }
         else
         {
             provider = LibraryProviderFrameworkImpl.get().getLastProviderUsed( this.fv );

             if( provider == null || ! this.providers.contains( provider ) )
             {
                 if( ! this.providers.isEmpty() )
                 {
                     provider = this.providers.iterator().next();
                 }
                 else
                 {
                     provider = null;
                 }
             }
         }

         setLibraryProvider( provider );

         for( LibraryProviderOperationConfig config : this.configs.values() )
         {
             config.reset();
         }
     }

     /**
      * Checks the validity of the library install configuration.
      *
      * @return a status object describing configuration problems, if any
      */

     public synchronized IStatus validate()
     {
         IStatus st = Status.OK_STATUS;

         if( this.providers.size() == 0 )
         {
             st = createErrorStatus( Resources.noProvidersAvailable );
         }
         else
         {
             final Object providerInstallOpConfig = this.configs.get( this.selectedProvider );

             if( providerInstallOpConfig instanceof LibraryProviderOperationConfig )
             {
                 st = ( (LibraryProviderOperationConfig) providerInstallOpConfig ).validate();
             }
         }

         return st;
     }

     /**
      * Executes the library install operation.
      *
      * @param monitor the progress monitor for reporting status and handling cancellation requests
      * @throws CoreException if failed for some reason while executing the install operation
      */

     public synchronized void execute( final IProgressMonitor monitor )

         throws CoreException

     {
         beginTask( monitor, "", 10 ); //$NON-NLS-1$

         try
         {
             final IFacetedProjectBase fproj = getFacetedProject();
             final IProjectFacetVersion fv = getProjectFacetVersion();
             final LibraryProvider provider = (LibraryProvider) getLibraryProvider();

             // Turn this into a no-op if the selected library provider is either the legacy
             // library provider or the unknown library provider. Those represent special corner
             // cases and the standard uninstall/install does not work. This comes up in the property
             // page case where the user hits ok without picking a different provider. Would be nice
             // if we could somehow turn this check into a more general "did user change" anything
             // check.

             final String rootLibraryProviderId = this.selectedProvider.getRootProvider().getId();

             if( rootLibraryProviderId.equals( "unknown-library-provider" ) || //$NON-NLS-1$
                 rootLibraryProviderId.equals( "legacy-library-provider" ) ) //$NON-NLS-1$
             {
                 return;
             }

             // Uninstall the previous library, if applicable.

             if( this.uninstallDelegate != null )
             {
                 this.uninstallDelegate.execute( new NullProgressMonitor() );
             }

             // Install the library.

             final LibraryProviderOperation libraryInstallOp
                 = provider.createOperation( LibraryProviderActionType.INSTALL );

             final LibraryProviderOperationConfig libraryInstallOpConfig
                 = getLibraryProviderOperationConfig();

             libraryInstallOp.execute( libraryInstallOpConfig, submon( monitor, 8 ) );

             // Record which library provider was used for this facet in workspace prefs. This
             // will be used to default the provider selection the next time this facet is installed.

             LibraryProviderFrameworkImpl.get().setLastProviderUsed( fv, provider );
             worked( monitor, 1 );

             // Record which library provider was used for this facet in project metadata. This
             // will be used to know which provider to use when the facet is being uninstalled or
             // the version is being changed.

             LibraryProviderFrameworkImpl.get().setCurrentProvider( fproj.getProject(), fv.getProjectFacet(), provider );

             worked( monitor, 1 );
         }
         finally
         {
             done( monitor );
         }
     }

     /**
      * Cleans up allocated resources. Client code that instantiates this class is responsible that the
      * instance is properly disposed by calling the dispose method.
      */

     public synchronized void dispose()
     {
     	if( this.uninstallDelegate != null )
     	{
     		this.uninstallDelegate.dispose();
     	}

         getFacetedProject().removeListener( this.facetedProjectListener );

         for( LibraryProviderOperationConfig cfg : this.configs.values() )
         {
             try
             {
                 cfg.dispose();
             }
             catch( Exception e )
             {
                 log( e );
             }
         }
     }

     private static final class Resources

         extends NLS

     {
         public static String noProvidersAvailable;

         static
         {
             initializeMessages( LibraryInstallDelegate.class.getName(),
                                 Resources.class );
         }
     }

 }
	/******************************************************************************
	* Copyright (c) 2010 Oracle
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* Contributors:
	* Konstantin Komissarchik - initial implementation and ongoing maintenance
	******************************************************************************/

	package org.eclipse.jst.common.project.facet.core.libprov;

	import static org.eclipse.jst.common.project.facet.core.internal.FacetedProjectFrameworkJavaPlugin.createErrorStatus;
	import static org.eclipse.jst.common.project.facet.core.internal.FacetedProjectFrameworkJavaPlugin.log;
	import static org.eclipse.wst.common.project.facet.core.util.internal.ProgressMonitorUtil.beginTask;
	import static org.eclipse.wst.common.project.facet.core.util.internal.ProgressMonitorUtil.done;
	import static org.eclipse.wst.common.project.facet.core.util.internal.ProgressMonitorUtil.submon;
	import static org.eclipse.wst.common.project.facet.core.util.internal.ProgressMonitorUtil.worked;
	import static org.eclipse.wst.common.project.facet.core.util.internal.MiscUtil.equal;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.jst.common.project.facet.core.libprov.internal.LibraryProvider;
	import org.eclipse.jst.common.project.facet.core.libprov.internal.LibraryProviderFrameworkImpl;
	import org.eclipse.jst.common.project.facet.core.libprov.internal.PropertiesHost;
	import org.eclipse.osgi.util.NLS;
	import org.eclipse.wst.common.project.facet.core.IFacetedProject;
	import org.eclipse.wst.common.project.facet.core.IFacetedProjectBase;
	import org.eclipse.wst.common.project.facet.core.IFacetedProjectWorkingCopy;
	import org.eclipse.wst.common.project.facet.core.IProjectFacet;
	import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
	import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectEvent;
	import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectListener;
	import org.eclipse.wst.common.project.facet.core.util.internal.CollectionsUtil;

	/**
	* Used for configuring and then installing a library via the Library Provider Framework.
	* Instance of this class would typically be embedded in facet action config objects and then
	* executed during the execution of those actions. Can also be used stand-alone when it is
	* necessary to change libraries outside facet lifecycle actions.
	*
	* @author <a href="mailto:konstantin.komissarchik@oracle.com">Konstantin Komissarchik</a>
	* @since 1.4
	*/

	public final class LibraryInstallDelegate

	extends PropertiesHost

	{
	private static final String CLASS_NAME = LibraryInstallDelegate.class.getName();

	/**
	* The property corresponding to the list of available providers.
	*/

	public static final String PROP_AVAILABLE_PROVIDERS
	= CLASS_NAME + ".AVAILABLE_PROVIDERS"; //$NON-NLS-1$

	/**
	* The property corresponding to the currently-selected provider.
	*/

	public static final String PROP_SELECTED_PROVIDER
	= CLASS_NAME + ".SELECTED_PROVIDER"; //$NON-NLS-1$

	private final IFacetedProjectBase fproj;
	private IProjectFacetVersion fv;
	private List<ILibraryProvider> providers;
	private List<ILibraryProvider> providersReadOnly;
	private ILibraryProvider selectedProvider;
	private boolean isDefaultSelection;
	private final Map<ILibraryProvider,LibraryProviderOperationConfig> configs;
	private final IPropertyChangeListener providerConfigListener;
	private LibraryUninstallDelegate uninstallDelegate = null;
	private Map<String,Object> customEnablementContextVariables;
	private final IFacetedProjectListener facetedProjectListener;

	/**
	* Constructs a new library install delegate.
	*
	* @param fproj the faceted project (or a working copy)
	* @param fv the project facet that is requesting libraries
	* @param customEnablementContextVariables custom variables to add to the expression
	* evaluation context for enablement expressions or <code>null</code> for none
	* @see #setEnablementContextVariable(String, Object)
	*/

	public LibraryInstallDelegate( final IFacetedProjectBase fproj,
	final IProjectFacetVersion fv,
	final Map<String,Object> customEnablementContextVariables )
	{
	this.fproj = fproj;
	this.fv = fv;
	this.providers = Collections.emptyList();
	this.providersReadOnly = Collections.emptyList();
	this.selectedProvider = null;
	this.isDefaultSelection = true;
	this.configs = new HashMap<ILibraryProvider,LibraryProviderOperationConfig>();
	this.customEnablementContextVariables = new HashMap<String,Object>();

	if( customEnablementContextVariables != null )
	{
	this.customEnablementContextVariables.putAll( customEnablementContextVariables );
	}

	this.providerConfigListener = new IPropertyChangeListener()
	{
	public void propertyChanged( final String property,
	final Object oldValue,
	final Object newValue )
	{
	notifyListeners( property, oldValue, newValue );
	}
	};

	this.facetedProjectListener = new IFacetedProjectListener()
	{
	public void handleEvent( final IFacetedProjectEvent event )
	{
	refresh();
	}
	};

	getFacetedProject().addListener( this.facetedProjectListener, IFacetedProjectEvent.Type.PROJECT_MODIFIED );

	reset();
	}

	/**
	* Constructs a new library install delegate.
	*
	* @param fproj the faceted project (or a working copy)
	* @param fv the project facet that is requesting libraries
	*/

	public LibraryInstallDelegate( final IFacetedProjectBase fproj,
	final IProjectFacetVersion fv )
	{
	this( fproj, fv, null );
	}

	/**
	* Returns the faceted project that this install delegate was configured to use. Can be a working
	* copy.
	*
	* @return the faceted project that this install delegate was configured to use
	*/

	public IFacetedProjectBase getFacetedProject()
	{
	return this.fproj;
	}

	/**
	* Returns the project facet that made the request for libraries.
	*
	* @return the project facet that made the request for libraries
	*/

	public synchronized IProjectFacet getProjectFacet()
	{
	return this.fv.getProjectFacet();
	}

	/**
	* Returns the project facet version that made the request for libraries.
	*
	* @return the project facet version that made the request for libraries
	*/

	public synchronized IProjectFacetVersion getProjectFacetVersion()
	{
	return this.fv;
	}

	/**
	* Changes the project facet version of the requesting facet after the library install
	* delegate has been created.
	*
	* @param fv the project facet version
	*/

	public synchronized void setProjectFacetVersion( final IProjectFacetVersion fv )
	{
	this.fv = fv;
	refresh();
	}

	/**
	* Returns the list of library providers that are currently available. The list is sorted
	* by library provider priority (highest priority first). To listen for changes to this
	* list use PROP_AVAILABLE_PROVIDERS.
	*
	* @return the list of library providers that are currently available
	*/

	public synchronized List<ILibraryProvider> getLibraryProviders()
	{
	return this.providersReadOnly;
	}

	/**
	* Returns the library provider that is currently selected. To list for changes to this
	* property use PROP_SELECTED_PROVIDER.
	*
	* @return the library provider that is currently selected
	*/

	public synchronized ILibraryProvider getLibraryProvider()
	{
	return this.selectedProvider;
	}

	/**
	* Sets the current library provider.
	*
	* @param provider the provider that should be selected
	*/

	public synchronized void setLibraryProvider( final ILibraryProvider provider )
	{
	setLibraryProvider( provider, false, true );
	}

	private synchronized void setLibraryProvider( final ILibraryProvider provider,
	final boolean isDefaultSelection,
	final boolean notifyListeners )
	{
	if( ! this.providers.contains( provider ) &&
	! ( this.providers.size() == 0 && provider == null ) )
	{
	throw new IllegalArgumentException();
	}

	if( ! equal( this.selectedProvider, provider ) )
	{
	final ILibraryProvider oldSelectedProvider = this.selectedProvider;

	this.selectedProvider = provider;
	this.isDefaultSelection = isDefaultSelection;

	final LibraryProviderOperationConfig config = this.configs.get( this.selectedProvider );

	if( config != null )
	{
	config.reset();
	}

	if( notifyListeners )
	{
	notifyListeners( PROP_SELECTED_PROVIDER, oldSelectedProvider, this.selectedProvider );
	}
	}
	}

	/**
	* Returns the install operation config of the currently-selected provider. This property's
	* lifecycle is bound to the current provider changes, so listen for changes using
	* PROP_SELECTED_PROVIDER.
	*
	* @return the install operation config of the currently-selected provider
	*/

	public synchronized LibraryProviderOperationConfig getLibraryProviderOperationConfig()
	{
	if( this.selectedProvider == null )
	{
	return null;
	}
	else
	{
	return this.configs.get( this.selectedProvider );
	}
	}

	/**
	* Returns the install operation config for any of the available library providers.
	*
	* @param provider the library provider to look up install operation config
	* @return the install operation config for any of the available library providers
	*/

	public synchronized LibraryProviderOperationConfig getLibraryProviderOperationConfig( final ILibraryProvider provider )
	{
	if( ! this.providers.contains( provider ) )
	{
	throw new IllegalArgumentException();
	}

	return this.configs.get( provider );
	}

	/**
	* Adds a custom variable to the expression evaluation context for enablement expressions
	* controlling activation of library providers. Setting the variable to <code>null</code>
	* has the effect of removing it. Calling this method will trigger a refresh of available
	* library providers.
	*
	* @param name the name of the variable
	* @param value the value of the variable
	*/

	public synchronized void setEnablementContextVariable( final String name,
	final Object value )
	{
	final Object currentValue = this.customEnablementContextVariables.get( name );

	if( ! equal( currentValue, value ) )
	{
	if( value == null )
	{
	this.customEnablementContextVariables.remove( name );
	}
	else
	{
	this.customEnablementContextVariables.put( name, value );
	}

	refresh();
	}
	}

	/**
	* Refreshes the list of available library providers and resets the current library provider
	* if the one currently selected is not in the available list any longer.
	*/

	public synchronized void refresh()
	{
	final IProjectFacet f = getProjectFacet();
	final IProjectFacetVersion fv = getProjectFacetVersion();
	final IFacetedProjectBase fproj = getFacetedProject();

	final List<ILibraryProvider> oldProviders = this.providers;

	for( ILibraryProvider provider : oldProviders )
	{
	final LibraryProviderOperationConfig config = this.configs.remove( provider );

	if( config != null )
	{
	config.removeListener( this.providerConfigListener );
	config.dispose();
	}
	}

	final List<ILibraryProvider> newProviders = new ArrayList<ILibraryProvider>();

	for( ILibraryProvider provider : LibraryProviderFramework.getProviders() )
	{
	if( ! provider.isAbstract() && ! provider.isHidden()
	&& provider.isEnabledFor( fproj, fv, this.customEnablementContextVariables ) )
	{
	newProviders.add( provider );
	}
	}

	final Comparator<ILibraryProvider> comp = CollectionsUtil.getInvertingComparator();
	Collections.sort( newProviders, comp );

	final IFacetedProject base;

	if( fproj instanceof IFacetedProject )
	{
	base = (IFacetedProject) fproj;
	}
	else
	{
	base = ( (IFacetedProjectWorkingCopy) fproj ).getFacetedProject();
	}

	if( base != null && base.hasProjectFacet( f ) )
	{
	// This code is here to take care of cases where framework injects a provider
	// that is not typically available for unknown and legacy usecases.

	final ILibraryProvider provider
	= LibraryProviderFramework.getCurrentProvider( base.getProject(), f );

	if( provider == null )
	{
	throw new RuntimeException();
	}

	if( ! newProviders.contains( provider ) )
	{
	newProviders.add( provider );
	}
	}

	this.providers = newProviders;
	this.providersReadOnly = Collections.unmodifiableList( this.providers );

	for( ILibraryProvider provider : this.providers )
	{
	final LibraryProvider prov = (LibraryProvider) provider;
	final LibraryProviderOperationConfig config = prov.createInstallOperationConfig( this );
	config.addListener( this.providerConfigListener );
	this.configs.put( provider, config );
	}

	final ILibraryProvider oldSelectedProvider = this.selectedProvider;

	if( this.providers.size() > 0 )
	{
	if( this.selectedProvider == null \|\| this.isDefaultSelection \|\|
	! this.providers.contains( this.selectedProvider ) )
	{
	ILibraryProvider provider = LibraryProviderFrameworkImpl.get().getLastProviderUsed( fv );

	if( provider == null \|\| ! this.providers.contains( provider ) )
	{
	provider = this.providers.iterator().next();
	}

	setLibraryProvider( provider, true, false );
	}
	}
	else
	{
	setLibraryProvider( null, true, false );
	}

	notifyListeners( PROP_AVAILABLE_PROVIDERS, oldProviders, this.providersReadOnly );

	if( ! equal( oldSelectedProvider, this.selectedProvider ) )
	{
	notifyListeners( PROP_SELECTED_PROVIDER, oldSelectedProvider, this.selectedProvider );
	}
	}

	/**
	* Resets this install delegate to its initial state (prior to any user changes).
	*/

	public synchronized void reset()
	{
	refresh();

	final IProjectFacet facet = this.fv.getProjectFacet();
	final IFacetedProject fpj;

	if( this.fproj instanceof IFacetedProject )
	{
	fpj = (IFacetedProject) this.fproj;
	}
	else
	{
	fpj = ( (IFacetedProjectWorkingCopy) this.fproj ).getFacetedProject();
	}

	ILibraryProvider provider = null;

	if( this.uninstallDelegate != null )
	{
	this.uninstallDelegate.dispose();
	this.uninstallDelegate = null;
	}

	if( fpj != null && fpj.hasProjectFacet( facet ) )
	{
	this.uninstallDelegate = new LibraryUninstallDelegate( fpj, this.fv );

	provider = LibraryProviderFramework.getCurrentProvider( fpj.getProject(), facet );

	if( provider == null )
	{
	throw new RuntimeException();
	}
	}
	else
	{
	provider = LibraryProviderFrameworkImpl.get().getLastProviderUsed( this.fv );

	if( provider == null \|\| ! this.providers.contains( provider ) )
	{
	if( ! this.providers.isEmpty() )
	{
	provider = this.providers.iterator().next();
	}
	else
	{
	provider = null;
	}
	}
	}

	setLibraryProvider( provider );

	for( LibraryProviderOperationConfig config : this.configs.values() )
	{
	config.reset();
	}
	}

	/**
	* Checks the validity of the library install configuration.
	*
	* @return a status object describing configuration problems, if any
	*/

	public synchronized IStatus validate()
	{
	IStatus st = Status.OK_STATUS;

	if( this.providers.size() == 0 )
	{
	st = createErrorStatus( Resources.noProvidersAvailable );
	}
	else
	{
	final Object providerInstallOpConfig = this.configs.get( this.selectedProvider );

	if( providerInstallOpConfig instanceof LibraryProviderOperationConfig )
	{
	st = ( (LibraryProviderOperationConfig) providerInstallOpConfig ).validate();
	}
	}

	return st;
	}

	/**
	* Executes the library install operation.
	*
	* @param monitor the progress monitor for reporting status and handling cancellation requests
	* @throws CoreException if failed for some reason while executing the install operation
	*/

	public synchronized void execute( final IProgressMonitor monitor )

	throws CoreException

	{
	beginTask( monitor, "", 10 ); //$NON-NLS-1$

	try
	{
	final IFacetedProjectBase fproj = getFacetedProject();
	final IProjectFacetVersion fv = getProjectFacetVersion();
	final LibraryProvider provider = (LibraryProvider) getLibraryProvider();

	// Turn this into a no-op if the selected library provider is either the legacy
	// library provider or the unknown library provider. Those represent special corner
	// cases and the standard uninstall/install does not work. This comes up in the property
	// page case where the user hits ok without picking a different provider. Would be nice
	// if we could somehow turn this check into a more general "did user change" anything
	// check.

	final String rootLibraryProviderId = this.selectedProvider.getRootProvider().getId();

	if( rootLibraryProviderId.equals( "unknown-library-provider" ) \|\| //$NON-NLS-1$
	rootLibraryProviderId.equals( "legacy-library-provider" ) ) //$NON-NLS-1$
	{
	return;
	}

	// Uninstall the previous library, if applicable.

	if( this.uninstallDelegate != null )
	{
	this.uninstallDelegate.execute( new NullProgressMonitor() );
	}

	// Install the library.

	final LibraryProviderOperation libraryInstallOp
	= provider.createOperation( LibraryProviderActionType.INSTALL );

	final LibraryProviderOperationConfig libraryInstallOpConfig
	= getLibraryProviderOperationConfig();

	libraryInstallOp.execute( libraryInstallOpConfig, submon( monitor, 8 ) );

	// Record which library provider was used for this facet in workspace prefs. This
	// will be used to default the provider selection the next time this facet is installed.

	LibraryProviderFrameworkImpl.get().setLastProviderUsed( fv, provider );
	worked( monitor, 1 );

	// Record which library provider was used for this facet in project metadata. This
	// will be used to know which provider to use when the facet is being uninstalled or
	// the version is being changed.

	LibraryProviderFrameworkImpl.get().setCurrentProvider( fproj.getProject(), fv.getProjectFacet(), provider );

	worked( monitor, 1 );
	}
	finally
	{
	done( monitor );
	}
	}

	/**
	* Cleans up allocated resources. Client code that instantiates this class is responsible that the
	* instance is properly disposed by calling the dispose method.
	*/

	public synchronized void dispose()
	{
	if( this.uninstallDelegate != null )
	{
	this.uninstallDelegate.dispose();
	}

	getFacetedProject().removeListener( this.facetedProjectListener );

	for( LibraryProviderOperationConfig cfg : this.configs.values() )
	{
	try
	{
	cfg.dispose();
	}
	catch( Exception e )
	{
	log( e );
	}
	}
	}

	private static final class Resources

	extends NLS

	{
	public static String noProvidersAvailable;

	static
	{
	initializeMessages( LibraryInstallDelegate.class.getName(),
	Resources.class );
	}
	}

	}