ridljar/com/sun/star/lib/uno/helper/Factory.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18 package com.sun.star.lib.uno.helper;
  19
  20 import com.sun.star.uno.XComponentContext;
  21 import com.sun.star.lang.XSingleComponentFactory;
  22 import com.sun.star.lang.XServiceInfo;
  23 import com.sun.star.lang.XInitialization;
  24 import com.sun.star.registry.XRegistryKey;
  25 import com.sun.star.uno.UnoRuntime;
  26
  27
  28 /** Factory helper class supporting com.sun.star.lang.XServiceInfo and
  29     com.sun.star.lang.XSingleComponentFactory.
  30
  31     <p>
  32     Note: This factory implementation does not support lang.XSingleServiceFactory.
  33     </p>
  34 */
  35 public class Factory
  36     extends ComponentBase
  37     implements XSingleComponentFactory, XServiceInfo
  38 {
  39     private static final boolean DEBUG = false;
  40
  41     /** Creates an object factory supporting interfaces
  42         com.sun.star.lang.XSingleComponentFactory and
  43         com.sun.star.lang.XServiceInfo
  44
  45         @param impl_class
  46                implementation class
  47         @param impl_name
  48                implementation name
  49         @param supported_services
  50                services implemented
  51         @return
  52                object factory
  53
  54         @since UDK 3.2.13
  55     */
  56     public static XSingleComponentFactory createComponentFactory(
  57         Class impl_class, String impl_name, String supported_services [] )
  58         throws com.sun.star.uno.RuntimeException
  59     {
  60         return new Factory( impl_class, impl_name, supported_services );
  61     }
  62
  63     /** Creates an object factory supporting interfaces
  64         com.sun.star.lang.XSingleComponentFactory and
  65         com.sun.star.lang.XServiceInfo
  66
  67         The implementation name is the name of the implementation class.
  68
  69         @param impl_class
  70                implementation class
  71         @param supported_services
  72                services implemented
  73         @return
  74                 object factory
  75     */
  76     public static XSingleComponentFactory createComponentFactory(
  77         Class impl_class, String supported_services [] )
  78         throws com.sun.star.uno.RuntimeException
  79     {
  80         return createComponentFactory(
  81             impl_class, impl_class.getName(), supported_services );
  82     }
  83     /** Writes component's implementation info to given registry key.
  84
  85         @param impl_name
  86                name of implementation
  87         @param supported_services
  88                supported services of implementation
  89         @param xKey
  90                registry key to write to
  91         @return
  92                 success
  93     */
  94     public static boolean writeRegistryServiceInfo(
  95         String impl_name, String supported_services [], XRegistryKey xKey )
  96     {
  97           try
  98         {
  99             XRegistryKey xNewKey = xKey.createKey( "/" + impl_name + "/UNO/SERVICES" );
 100             for ( int nPos = 0; nPos < supported_services.length; ++nPos )
 101             {
 102                 xNewKey.createKey( supported_services[ nPos ] );
 103             }
 104             return true;
 105           }
 106           catch (com.sun.star.registry.InvalidRegistryException exc)
 107         {
 108             if (DEBUG)
 109             {
 110                 System.err.println(
 111                     "##### " + Factory.class.getName() + ".writeRegistryServiceInfo -- exc: " +
 112                     exc.toString() );
 113             }
 114           }
 115         return false;
 116     }
 117
 118
 119     private final String m_impl_name;
 120     private final String [] m_supported_services;
 121     private final Class<?> m_impl_class;
 122     private final java.lang.reflect.Method m_method;
 123     private final java.lang.reflect.Constructor m_ctor;
 124
 125     private Factory(
 126         Class impl_class, String impl_name, String supported_services [] )
 127                 throws com.sun.star.uno.DeploymentException
 128     {
 129         m_impl_name = impl_name;
 130         m_supported_services = supported_services;
 131         m_impl_class = impl_class;
 132
 133         Class params [] = new Class [] { XComponentContext.class };
 134
 135         if (!java.lang.reflect.Modifier.isPublic( impl_class.getModifiers() ))
 136         {
 137             throw new com.sun.star.uno.DeploymentException("class " + impl_class + " is not public");
 138         }
 139
 140         java.lang.reflect.Method tmpMethod = null;
 141         try
 142         {
 143             // seeking for "public static Object __create( XComponentContext )"
 144             tmpMethod = m_impl_class.getMethod( "__create", params );
 145             int mod = tmpMethod.getModifiers();
 146             if (!tmpMethod.getReturnType().equals( Object.class ) ||
 147                 !java.lang.reflect.Modifier.isStatic( mod ) ||
 148                 !java.lang.reflect.Modifier.isPublic( mod ))
 149             {
 150                 tmpMethod = null;
 151             }
 152         }
 153         catch (Exception exc)
 154         {
 155         }
 156         m_method = tmpMethod;
 157
 158
 159         java.lang.reflect.Constructor tmpCtor = null;
 160         if (null == m_method)
 161         {
 162             try
 163             {
 164                 // ctor with context
 165                 tmpCtor = m_impl_class.getConstructor( params );
 166             }
 167             catch (Exception exc)
 168             {
 169             }
 170             if (tmpCtor != null)
 171             {
 172                 if (!java.lang.reflect.Modifier.isPublic( tmpCtor.getModifiers() ))
 173                 {
 174                     throw new com.sun.star.uno.DeploymentException("constructor with XComponentContext param for class  " + impl_class + " is not public");
 175                 }
 176             }
 177             else
 178             {
 179                 // else take default ctor
 180                 java.lang.reflect.Constructor defaultCtor;
 181                 try
 182                 {
 183                     defaultCtor = m_impl_class.getConstructor(new Class[0]);
 184                 }
 185                 catch (Exception exc2)
 186                 {
 187                     throw new com.sun.star.uno.DeploymentException(exc2, "class " + impl_class + " has no means of creating it, cannot find a __create method or a useful constructor.");
 188                 }
 189                 if (!java.lang.reflect.Modifier.isPublic( defaultCtor.getModifiers() ))
 190                 {
 191                     throw new com.sun.star.uno.DeploymentException("default constructor for class  " + impl_class + " is not public");
 192                 }
 193             }
 194         }
 195         m_ctor = tmpCtor;
 196     }
 197
 198
 199     private Object instantiate( XComponentContext xContext )
 200         throws com.sun.star.uno.Exception
 201     {
 202         try
 203         {
 204             if (DEBUG)
 205                 System.out.print( "instantiating " + m_impl_class.toString() + " using " );
 206             if (null != m_method)
 207             {
 208                 if (DEBUG)
 209                     System.out.println( "__create( XComponentContext )..." );
 210                 return m_method.invoke( null, new Object [] { xContext } );
 211             }
 212             if (null != m_ctor)
 213             {
 214                 if (DEBUG)
 215                     System.out.println( "ctor( XComponentContext )..." );
 216                 return m_ctor.newInstance( new Object [] { xContext } );
 217             }
 218             if (DEBUG)
 219                 System.out.println( "default ctor..." );
 220             return m_impl_class.newInstance(); // default ctor
 221         }
 222         catch (java.lang.reflect.InvocationTargetException exc)
 223         {
 224             Throwable targetException = exc.getTargetException();
 225             if (targetException instanceof java.lang.RuntimeException)
 226                 throw (java.lang.RuntimeException)targetException;
 227             else if (targetException instanceof com.sun.star.uno.RuntimeException)
 228                 throw (com.sun.star.uno.RuntimeException)targetException;
 229             else if (targetException instanceof com.sun.star.uno.Exception)
 230                 throw (com.sun.star.uno.Exception)targetException;
 231             else
 232                 throw new com.sun.star.uno.Exception(targetException, targetException.getMessage(), this);
 233         }
 234         catch (IllegalAccessException exc)
 235         {
 236             throw new com.sun.star.uno.RuntimeException( exc, exc.getMessage(), this);
 237         }
 238         catch (InstantiationException exc)
 239         {
 240             throw new com.sun.star.uno.RuntimeException( exc, exc.getMessage(), this);
 241         }
 242     }
 243     // XSingleComponentFactory impl
 244
 245     public final Object createInstanceWithContext(
 246         XComponentContext xContext )
 247         throws com.sun.star.uno.Exception
 248     {
 249         return instantiate( xContext );
 250     }
 251
 252     public final Object createInstanceWithArgumentsAndContext(
 253         Object arguments [], XComponentContext xContext )
 254         throws com.sun.star.uno.Exception
 255     {
 256         Object inst = instantiate( xContext );
 257         XInitialization xInit = UnoRuntime.queryInterface(
 258             XInitialization.class, inst );
 259         if (null == xInit)
 260         {
 261             throw new com.sun.star.lang.IllegalArgumentException(
 262                 "cannot pass arguments to component; no XInitialization implemented!", this,
 263                 (short)0 );
 264         }
 265         xInit.initialize( arguments );
 266         return inst;
 267     }
 268
 269     // XServiceInfo impl
 270
 271     public final String getImplementationName()
 272     {
 273         return m_impl_name;
 274     }
 275
 276     public final boolean supportsService( String service_name )
 277     {
 278         for ( int nPos = 0; nPos < m_supported_services.length; ++nPos )
 279         {
 280             if (m_supported_services[ nPos ].equals( service_name ))
 281                 return true;
 282         }
 283         return false;
 284     }
 285
 286     public final String [] getSupportedServiceNames()
 287     {
 288         return m_supported_services;
 289     }
 290 }
 291