| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include <osl/interlck.h> |
| #include <osl/mutex.hxx> |
| #include <rtl/uuid.h> |
| #include <cppuhelper/factory.hxx> |
| |
| #include <com/sun/star/lang/XServiceInfo.hpp> |
| #include <com/sun/star/lang/XTypeProvider.hpp> |
| #include <my_module/XSomething.hpp> |
| |
| |
| using namespace ::rtl; // for OUString |
| using namespace ::com::sun::star; // for odk interfaces |
| using namespace ::com::sun::star::uno; // for basic types |
| |
| namespace my_sc_impl |
| { |
| |
| Sequence< OUString > SAL_CALL getSupportedServiceNames_MyService1Impl() |
| { |
| Sequence< OUString > names(1); |
| names[0] = OUString(RTL_CONSTASCII_USTRINGPARAM("my_module.MyService1")); |
| return names; |
| } |
| |
| OUString SAL_CALL getImplementationName_MyService1Impl() |
| { |
| return OUString( RTL_CONSTASCII_USTRINGPARAM( |
| "my_module.my_sc_implementation.MyService1") ); |
| } |
| |
| |
| class MyService1Impl |
| : public ::my_module::XSomething |
| , public lang::XServiceInfo |
| , public lang::XTypeProvider |
| { |
| oslInterlockedCount m_refcount; |
| OUString m_sData; |
| // it's good practise to store the context for further use when you use |
| // other UNO API's in your implementation |
| Reference< XComponentContext > m_xContext; |
| public: |
| inline MyService1Impl(Reference< XComponentContext > const & xContext) throw () |
| : m_refcount( 0 ), |
| m_xContext(xContext) |
| {} |
| |
| virtual ~MyService1Impl() {} |
| |
| // XInterface |
| virtual Any SAL_CALL queryInterface( Type const & type ) |
| throw (RuntimeException); |
| virtual void SAL_CALL acquire() |
| throw (); |
| virtual void SAL_CALL release() |
| throw (); |
| // XTypeProvider |
| virtual Sequence< Type > SAL_CALL getTypes() |
| throw (RuntimeException); |
| virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() |
| throw (RuntimeException); |
| // XSomething |
| virtual OUString SAL_CALL methodOne( OUString const & str ) |
| throw (RuntimeException); |
| virtual OUString SAL_CALL methodTwo( ) |
| throw (RuntimeException); |
| // XServiceInfo |
| virtual OUString SAL_CALL getImplementationName() |
| throw (RuntimeException); |
| virtual sal_Bool SAL_CALL supportsService( OUString const & serviceName ) |
| throw (RuntimeException); |
| virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() |
| throw (RuntimeException); |
| }; |
| |
| // XInterface implementation |
| Any MyService1Impl::queryInterface( Type const & type ) |
| throw (RuntimeException) |
| { |
| if (type.equals(::cppu::UnoType< Reference< XInterface > >::get())) |
| { |
| // return XInterface interface |
| // (resolve ambiguity by casting to lang::XTypeProvider) |
| Reference< XInterface > x( |
| static_cast< lang::XTypeProvider * >( this ) ); |
| return makeAny( x ); |
| } |
| if (type.equals(::cppu::UnoType< Reference< lang::XTypeProvider > >::get())) |
| { |
| // return XInterface interface |
| Reference< XInterface > x( |
| static_cast< lang::XTypeProvider * >( this ) ); |
| return makeAny( x ); |
| } |
| if (type.equals(::cppu::UnoType< Reference< lang::XServiceInfo > >::get())) |
| { |
| // return XServiceInfo interface |
| Reference< lang::XServiceInfo > x( |
| static_cast< lang::XServiceInfo * >( this ) ); |
| return makeAny( x ); |
| } |
| if (type.equals(::cppu::UnoType< Reference< ::my_module::XSomething > >::get())) |
| { |
| // return sample interface |
| Reference< ::my_module::XSomething > x( |
| static_cast< ::my_module::XSomething * >( this ) ); |
| return makeAny( x ); |
| } |
| // querying for unsupported type |
| return Any(); |
| } |
| |
| void MyService1Impl::acquire() |
| throw () |
| { |
| // thread-safe incrementation of reference count |
| ::osl_incrementInterlockedCount( &m_refcount ); |
| } |
| |
| void MyService1Impl::release() |
| throw () |
| { |
| // thread-safe decrementation of reference count |
| if (0 == ::osl_decrementInterlockedCount( &m_refcount )) |
| { |
| delete this; // shutdown this object |
| } |
| } |
| |
| // XTypeProvider implementation |
| Sequence< Type > MyService1Impl::getTypes() |
| throw (RuntimeException) |
| { |
| Sequence< Type > seq( 3 ); |
| seq[ 0 ] = ::cppu::UnoType< Reference< lang::XTypeProvider > >::get(); |
| seq[ 1 ] = ::cppu::UnoType< Reference< lang::XServiceInfo > >::get(); |
| seq[ 2 ] = ::cppu::UnoType< Reference< ::my_module::XSomething > >::get(); |
| return seq; |
| } |
| Sequence< sal_Int8 > MyService1Impl::getImplementationId() |
| throw (RuntimeException) |
| { |
| static Sequence< sal_Int8 > * s_pId = 0; |
| if (! s_pId) |
| { |
| // create unique id |
| Sequence< sal_Int8 > id( 16 ); |
| ::rtl_createUuid( (sal_uInt8 *)id.getArray(), 0, sal_True ); |
| // guard initialization with some mutex |
| ::osl::MutexGuard guard( ::osl::Mutex::getGlobalMutex() ); |
| if (! s_pId) |
| { |
| static Sequence< sal_Int8 > s_id( id ); |
| s_pId = &s_id; |
| } |
| } |
| return *s_pId; |
| } |
| |
| // XSomething implementation |
| OUString MyService1Impl::methodOne( OUString const & str ) |
| throw (RuntimeException) |
| { |
| m_sData = str; |
| return OUString( RTL_CONSTASCII_USTRINGPARAM( |
| "called methodOne() of MyService1 implementation: ") ) + m_sData; |
| } |
| |
| OUString MyService1Impl::methodTwo( ) |
| throw (RuntimeException) |
| { |
| return OUString( RTL_CONSTASCII_USTRINGPARAM( |
| "called methodTwo() of MyService1 implementation: ") ) + m_sData; |
| } |
| |
| // XServiceInfo implementation |
| OUString MyService1Impl::getImplementationName() |
| throw (RuntimeException) |
| { |
| // unique implementation name |
| return OUString( RTL_CONSTASCII_USTRINGPARAM( |
| "my_module.my_sc_implementation.MyService1") ); |
| } |
| sal_Bool MyService1Impl::supportsService( OUString const & serviceName ) |
| throw (RuntimeException) |
| { |
| // this object only supports one service, so the test is simple |
| return serviceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( |
| "my_module.MyService1") ); |
| } |
| Sequence< OUString > MyService1Impl::getSupportedServiceNames() |
| throw (RuntimeException) |
| { |
| // this object only supports one service |
| OUString serviceName( RTL_CONSTASCII_USTRINGPARAM("my_module.MyService1") ); |
| return Sequence< OUString >( &serviceName, 1 ); |
| } |
| |
| Reference< XInterface > SAL_CALL create_MyService1Impl( |
| Reference< XComponentContext > const & xContext ) |
| SAL_THROW( () ) |
| { |
| return static_cast< lang::XTypeProvider * >( new MyService1Impl( xContext) ); |
| } |
| |
| // forward decl: implemented in service2_impl.cxx |
| Reference< XInterface > SAL_CALL create_MyService2Impl( |
| Reference< XComponentContext > const & ) SAL_THROW( () ); |
| |
| } |
| |
| /* |
| extern "C" SAL_DLLPUBLIC_EXPORT void SAL_CALL component_getImplementationEnvironment( |
| sal_Char const ** ppEnvTypeName, uno_Environment ** ) |
| { |
| *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME; |
| } |
| |
| // This method not longer necessary since OOo 3.4 where the component registration was |
| // was changed to passive component registration. For more details see |
| // http://wiki.services.openoffice.org/wiki/Passive_Component_Registration |
| // |
| // extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool SAL_CALL component_writeInfo( |
| // lang::XMultiServiceFactory * xMgr, registry::XRegistryKey * xRegistry ) |
| // { |
| // if (xRegistry) |
| // { |
| // try |
| // { |
| // // implementation of MyService1A |
| // Reference< registry::XRegistryKey > xKey( |
| // xRegistry->createKey( OUString( RTL_CONSTASCII_USTRINGPARAM( |
| // "my_module.my_sc_implementation.MyService1/UNO/SERVICES") ) ) ); |
| // // subkeys denote implemented services of implementation |
| // xKey->createKey( OUString( RTL_CONSTASCII_USTRINGPARAM( |
| // "my_module.MyService1") ) ); |
| // // implementation of MyService1B |
| // xKey = xRegistry->createKey( OUString( RTL_CONSTASCII_USTRINGPARAM( |
| // "my_module.my_sc_implementation.MyService2/UNO/SERVICES") ) ); |
| // // subkeys denote implemented services of implementation |
| // xKey->createKey( OUString( RTL_CONSTASCII_USTRINGPARAM( |
| // "my_module.MyService2") ) ); |
| // return sal_True; // success |
| // } |
| // catch (registry::InvalidRegistryException &) |
| // { |
| // // function fails if exception caught |
| // } |
| // } |
| // return sal_False; |
| // } |
| |
| extern "C" SAL_DLLPUBLIC_EXPORT void * SAL_CALL component_getFactory( |
| sal_Char const * implName, lang::XMultiServiceFactory * xMgr, void * ) |
| { |
| Reference< lang::XSingleComponentFactory > xFactory; |
| if (0 == ::rtl_str_compare( implName, "my_module.my_sc_implementation.MyService1" )) |
| { |
| // create component factory for MyService1 implementation |
| OUString serviceName( RTL_CONSTASCII_USTRINGPARAM("my_module.MyService1") ); |
| xFactory = ::cppu::createSingleComponentFactory( |
| ::my_sc_impl::create_MyService1Impl, |
| OUString( RTL_CONSTASCII_USTRINGPARAM("my_module.my_sc_implementation.MyService1") ), |
| Sequence< OUString >( &serviceName, 1 ) ); |
| } |
| else if (0 == ::rtl_str_compare( implName, "my_module.my_sc_implementation.MyService2" )) |
| { |
| // create component factory for MyService12 implementation |
| OUString serviceName( RTL_CONSTASCII_USTRINGPARAM("my_module.MyService2") ); |
| xFactory = ::cppu::createSingleComponentFactory( |
| ::my_sc_impl::create_MyService2Impl, |
| OUString( RTL_CONSTASCII_USTRINGPARAM("my_module.my_sc_implementation.MyService2") ), |
| Sequence< OUString >( &serviceName, 1 ) ); |
| } |
| if (xFactory.is()) |
| xFactory->acquire(); |
| return xFactory.get(); // return acquired interface pointer or null |
| } |
| */ |
| |
