xref: /aoo41x/main/jurt/com/sun/star/comp/loader/JavaLoader.java (revision 2be43276)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



package com.sun.star.comp.loader;

import java.lang.reflect.Method;

import java.lang.reflect.InvocationTargetException;

import java.net.URLDecoder;

import com.sun.star.loader.CannotActivateFactoryException;
import com.sun.star.loader.XImplementationLoader;

import com.sun.star.registry.CannotRegisterImplementationException;
import com.sun.star.registry.XRegistryKey;

import com.sun.star.lang.XSingleComponentFactory;
import com.sun.star.lang.XSingleServiceFactory;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.lang.XInitialization;

import com.sun.star.uno.XComponentContext;
import com.sun.star.beans.XPropertySet;
import com.sun.star.util.XMacroExpander;

import com.sun.star.uno.Type;
import com.sun.star.uno.UnoRuntime;

import com.sun.star.lib.util.StringHelper;

import com.sun.star.uno.AnyConverter;


/**
 * The <code>JavaLoader</code> class provides the functionality of the <code>com.sun.star.loader.Java</code>
 * service. Therefor the <code>JavaLoader</code> activates external UNO components which are implemented in Java.
 * The loader is used by the <code>ServiceManger</code>.
 * <p>
 * @version 	$Revision: 1.16 $ $ $Date: 2008-04-11 11:10:31 $
 * @author 	    Markus Herzog
 * @see         com.sun.star.loader.XImplementationLoader
 * @see         com.sun.star.loader.Java
 * @see         com.sun.star.comp.servicemanager.ServiceManager
 * @see			com.sun.star.lang.ServiceManager
 * @since       UDK1.0
 */
public class JavaLoader implements XImplementationLoader,
                                   XServiceInfo,
                                   XInitialization
{
	private static final boolean DEBUG = false;

	private static final void DEBUG(String dbg) {
	    if (DEBUG) System.err.println( dbg );
	}

    private static String[] supportedServices = {
        "com.sun.star.loader.Java"
    };

	protected XMultiServiceFactory multiServiceFactory = null;

	private XMacroExpander m_xMacroExpander = null;
    private static final String EXPAND_PROTOCOL_PREFIX = "vnd.sun.star.expand:";

    /** Expands macrofied url using the macro expander singleton.
     */
    private String expand_url( String url ) throws RuntimeException
    {
        if (url != null && url.startsWith( EXPAND_PROTOCOL_PREFIX ))
        {
            try
            {
                if (m_xMacroExpander == null)
                {
                    XPropertySet xProps =
                        UnoRuntime.queryInterface(
                            XPropertySet.class, multiServiceFactory );
                    if (xProps == null)
                    {
                        throw new com.sun.star.uno.RuntimeException(
                            "service manager does not support XPropertySet!",
                            this );
                    }
                    XComponentContext xContext = (XComponentContext)
                        AnyConverter.toObject(
                            new Type( XComponentContext.class ),
                            xProps.getPropertyValue( "DefaultContext" ) );
                    m_xMacroExpander = (XMacroExpander)AnyConverter.toObject(
                        new Type( XMacroExpander.class ),
                        xContext.getValueByName(
                            "/singletons/com.sun.star.util.theMacroExpander" )
                        );
                }
                // decode uric class chars
                String macro = URLDecoder.decode(
                    StringHelper.replace(
                        url.substring( EXPAND_PROTOCOL_PREFIX.length() ),
                        '+', "%2B" ) );
                // expand macro string
                String ret = m_xMacroExpander.expandMacros( macro );
                if (DEBUG)
                {
                    System.err.println(
                        "JavaLoader.expand_url(): " + url + " => " +
                        macro + " => " + ret );
                }
                return ret;
            }
            catch (com.sun.star.uno.Exception exc)
            {
                throw new com.sun.star.uno.RuntimeException(
                    exc.getMessage(), this );
            }
            catch (java.lang.Exception exc)
            {
                throw new com.sun.star.uno.RuntimeException(
                    exc.getMessage(), this );
            }
        }
        return url;
    }

	/** default constructor
	 */

	/**
	 * Creates a new instance of the <code>JavaLoader</code> class.
	 * <p>
	 * @return	new instance
	 */
	public JavaLoader() {}

	/**
	 * Creates a new <code>JavaLoader</code> object. The specified <code>com.sun.star.lang.XMultiServiceFactory</code>
	 * is the <code>ServiceManager</code> service which can be deliviert to all components the <code>JavaLoader</code> is
	 * loading.
	 * To set the <code>MultiServiceFactory</code> you can use the <code>com.sun.star.lang.XInitialization</code> interface, either.
	 * <p>
	 * @return	new instance
	 * @param	factory		the <code>ServiceManager</code>
	 * @see		com.sun.star.lang.ServiceManager
	 * @see		com.sun.star.lang.ServiceManager
	 * @see		com.sun.star.lang.XInitialization
	 */
	public JavaLoader(XMultiServiceFactory factory) {
	    multiServiceFactory = factory;
	}

	/**
     * Unlike the original intention, the method could be called every time a new
     * <code>com.sun.star.lang.XMultiServiceFactory</code> should be set at the loader.
	 * <p>
	 * @param		args - the first parameter (args[0]) specifices the <code>ServiceManager</code>
	 * @see		    com.sun.star.lang.XInitialization
	 * @see		    com.sun.star.lang.ServiceManager
	 */
    public void initialize( java.lang.Object[] args )
            throws com.sun.star.uno.Exception,
                   com.sun.star.uno.RuntimeException
    {
        if (args.length == 0) throw new com.sun.star.lang.IllegalArgumentException("No arguments specified");

        try {
            multiServiceFactory = (XMultiServiceFactory) AnyConverter.toObject(
                new Type(XMultiServiceFactory.class), args[0]);
        }
        catch (ClassCastException castEx) {
            throw new com.sun.star.lang.IllegalArgumentException(
                "The argument must be an instance of XMultiServiceFactory");
        }
    }

	/**
	 * Supplies the implementation name of the component.
	 * <p>
	 * @return      the implementation name - here the class name
	 * @see			com.sun.star.lang.XServiceInfo
	 */
	public String getImplementationName()
            throws com.sun.star.uno.RuntimeException
    {
		return getClass().getName();
	}

	/**
	 * Verifies if a given service is supported by the component.
	 * <p>
	 * @return		true,if service is suported - otherwise false
	 * @param		serviceName		the name of the service that should be checked
	 * @see			com.sun.star.lang.XServiceInfo
	 */
	public boolean supportsService(String serviceName)
	        throws com.sun.star.uno.RuntimeException
	{
		for ( int i = 0; i < supportedServices.length; i++ ) {
			if ( supportedServices[i].equals(serviceName) )
				return true;
		}
		return false;
	}

	/**
	 * Supplies a list of all service names supported by the component
	 * <p>
	 * @return		a String array with all supported services
	 * @see			com.sun.star.lang.XServiceInfo
	 */
	public String[] getSupportedServiceNames()
	        throws com.sun.star.uno.RuntimeException
	{
		return supportedServices;
	}

	/**
	 * Provides a components factory.
	 * The <code>JavaLoader</code> tries to load the class first. If a loacation URL is given the
	 * RegistrationClassFinder is used to load the class. Otherwise the class is loaded thru the Class.forName
	 * method.
	 * To get the factory the inspects the class for the optional static member functions __getServiceFactory resp.
	 * getServiceFactory (DEPRECATED).
	 * If the function can not be found a default factory @see ComponentFactoryWrapper will be created.
	 * <p>
	 * @return		the factory for the component (@see com.sun.star.lang.XSingleServiceFactory)
	 * @param      	implementationName			the implementation (class) name of the component
	 * @param      	implementationLoaderUrl		the URL of the implementation loader. Not used.
	 * @param      	locationUrl					points to an archive (JAR file) which contains a component
	 * @param      	xKey
	 * @see		   	com.sun.star.lang.XImplementationLoader
	 * @see			com.sun.star.com.loader.RegistrationClassFinder
	 */
	public java.lang.Object activate( String implementationName,
	                                  String implementationLoaderUrl,
	                                  String locationUrl,
	                                  XRegistryKey xKey )
        throws CannotActivateFactoryException,
               com.sun.star.uno.RuntimeException
    {
        locationUrl = expand_url( locationUrl );

		Object returnObject  = null;
	    Class clazz  ;

	    DEBUG("try to get factory for " + implementationName);

	    // first we must get the class of the implementation
	    // 1. If a location URL is given it is assumed that this points to a JAR file.
	    //    The components class name is stored in the manifest file.
	    // 2. If only the implementation name is given, the class is loaded with the
	    //    Class.forName() method. This is a hack to load bootstrap components.
        //    Normally a string must no be null.
	    try {
		    if ( locationUrl != null ) {
		    	// 1.
	    		clazz = RegistrationClassFinder.find( locationUrl );
		    }
		    else {
		    	// 2.
	    		clazz = Class.forName( implementationName );
			}
		}
		catch (java.net.MalformedURLException e) {
			CannotActivateFactoryException cae = new CannotActivateFactoryException(
					"Can not activate factory because " + e.toString() );
			cae.fillInStackTrace();
			throw cae;
		}
		catch (java.io.IOException e) {
			CannotActivateFactoryException cae = new CannotActivateFactoryException(
					"Can not activate factory because " + e.toString() );
			cae.fillInStackTrace();
			throw cae;
		}
		catch (java.lang.ClassNotFoundException e) {
			CannotActivateFactoryException cae = new CannotActivateFactoryException(
					"Can not activate factory because " + e.toString() );
			cae.fillInStackTrace();
			throw cae;
		}

        if (null == clazz)
        {
            CannotActivateFactoryException cae =
                new CannotActivateFactoryException(
                    "Cannot determine activation class!" );
			cae.fillInStackTrace();
			throw cae;
        }

		Class[] paramTypes = {String.class, XMultiServiceFactory.class, XRegistryKey.class};
		Object[] params = { implementationName, multiServiceFactory, xKey };

        // try to get factory from implemetation class
        // latest style: use the public static method __getComponentFactory
        // - new style: use the public static method __getServiceFactory
        // - old style: use the public static method getServiceFactory ( DEPRECATED )

        Method compfac_method = null;
		try
        {
		 	compfac_method = clazz.getMethod(
                "__getComponentFactory", new Class [] { String.class } );
		}
		catch ( NoSuchMethodException noSuchMethodEx) {}
		catch ( SecurityException secEx) {}

        Method method = null;
        if (null == compfac_method)
        {
            try {
                method = clazz.getMethod("__getServiceFactory", paramTypes);
            }
            catch ( NoSuchMethodException noSuchMethodEx) {
                method = null;
            }
            catch ( SecurityException secEx) {
                method = null;
            }
        }

		try {
            if (null != compfac_method)
            {
                Object ret = compfac_method.invoke( clazz, new Object [] { implementationName } );
                if (null == ret || !(ret instanceof XSingleComponentFactory))
                {
                    throw new CannotActivateFactoryException(
                        "No factory object for " + implementationName );
                }
                return (XSingleComponentFactory)ret;
            }
            else
            {
                if ( method == null ) {
                    method = clazz.getMethod("getServiceFactory", paramTypes);
                }

                Object oRet = method.invoke(clazz, params);

                if ( (oRet != null) && (oRet instanceof XSingleServiceFactory) ) {
                    returnObject = (XSingleServiceFactory) oRet;
                }
            }
    	}
		catch ( NoSuchMethodException e) {
            throw new CannotActivateFactoryException("Can not activate the factory for "
                        + implementationName + " because " + e.toString() );
		}
		catch ( SecurityException e) {
            throw new CannotActivateFactoryException("Can not activate the factory for "
						+ implementationName + " because " + e.toString() );
		}
		catch ( IllegalAccessException e ) {
			throw new CannotActivateFactoryException("Can not activate the factory for "
						+ implementationName + " because " + e.toString() );
		}
		catch ( IllegalArgumentException e ) {
			throw new CannotActivateFactoryException("Can not activate the factory for "
						+ implementationName + " because " + e.toString() );
		}
		catch ( InvocationTargetException e ) {
			throw new CannotActivateFactoryException("Can not activate the factory for "
						+ implementationName + " because " + e.getTargetException().toString() );
		}

		return returnObject;
	}

	/**
	 * Registers the component in a registry under a given root key. If the component supports the optional
	 * methods __writeRegistryServiceInfo, writeRegistryServiceInfo (DEPRECATED), the call is delegated to that
	 * method. Otherwise a default registration will be accomplished.
	 * <p>
	 * @return		true if registration is successfully - otherwise false
	 * @param		regKey					the root key under that the component should be registred.
	 * @param		implementationLoaderUrl	specifies the loader, the component is loaded by.
	 * @param		locationUrl				points to an archive (JAR file) which contains a component
	 * @see 		ComponentFactoryWrapper
	 */
	public boolean writeRegistryInfo( XRegistryKey regKey,
	                                  String implementationLoaderUrl,
	                                  String locationUrl )
	        throws CannotRegisterImplementationException,
	               com.sun.star.uno.RuntimeException
	{
        locationUrl = expand_url( locationUrl );

		boolean success = false;

        try {

    		Class clazz = RegistrationClassFinder.find(locationUrl);
            if (null == clazz)
            {
                throw new CannotRegisterImplementationException(
                    "Cannot determine registration class!" );
            }

			Class[] paramTypes = { XRegistryKey.class };
			Object[] params = { regKey };

			Method method  = clazz.getMethod("__writeRegistryServiceInfo", paramTypes);
			Object oRet = method.invoke(clazz, params);

			if ( (oRet != null) && (oRet instanceof Boolean) )
				success = ((Boolean) oRet).booleanValue();
        }
		catch (Exception e) {
            throw new CannotRegisterImplementationException( e.getMessage());
 		}

		return success;
	}

	/**
	 * Supplies the factory for the <code>JavaLoader</code>
	 * <p>
	 * @return	the factory for the <code>JavaLoader</code>
	 * @param	implName		the name of the desired component
	 * @param   multiFactory	the <code>ServiceManager</code> is delivered to the factory
	 * @param   regKey			not used - can be null
	 */
	public static XSingleServiceFactory getServiceFactory( String implName,
	                                                       XMultiServiceFactory multiFactory,
	                                                       XRegistryKey regKey)
	{
	    if ( implName.equals(JavaLoader.class.getName()) )
	        return new JavaLoaderFactory( multiFactory );

	    return null;
	}

	/**
	 * Registers the <code>JavaLoader</code> at the registry.
	 * <p>
	 * @return     true if registration succseeded - otherwise false
	 * @param      regKey	root key under which the <code>JavaLoader</code> should be regidstered
	 */
	public static boolean writeRegistryServiceInfo(XRegistryKey regKey) {
	    boolean result = false;

	    try {
	        XRegistryKey newKey = regKey.createKey("/" + JavaLoader.class.getName() + "/UNO/SERVICE");

	        for (int i=0; i<supportedServices.length; i++)
	            newKey.createKey(supportedServices[i]);

	        result = true;
	    }
	    catch (Exception ex) {
	        if (DEBUG) System.err.println(">>>JavaLoader.writeRegistryServiceInfo " + ex);
	    }

	    return result;
    }
}