framework/source/jobs/jobdispatch.cxx

   1     /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: jobdispatch.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_framework.hxx"
  33
  34 //________________________________
  35 //      my own includes
  36 #include <jobs/jobdispatch.hxx>
  37 #include <jobs/joburl.hxx>
  38 #include <jobs/job.hxx>
  39 #include <threadhelp/readguard.hxx>
  40 #include <threadhelp/writeguard.hxx>
  41 #include <threadhelp/resetableguard.hxx>
  42 #include <classes/converter.hxx>
  43 #include <general.h>
  44 #include <services.h>
  45
  46 //________________________________
  47 //      interface includes
  48 #include <com/sun/star/beans/XPropertySet.hpp>
  49 #include <com/sun/star/frame/DispatchResultState.hpp>
  50
  51 //________________________________
  52 //      includes of other projects
  53 #include <rtl/ustrbuf.hxx>
  54 #include <vcl/svapp.hxx>
  55
  56 //________________________________
  57 //      namespace
  58
  59 namespace framework{
  60
  61 //________________________________
  62 //      non exported const
  63
  64 //________________________________
  65 //      non exported definitions
  66
  67 //________________________________
  68 //      declarations
  69
  70 DEFINE_XINTERFACE_6( JobDispatch                                     ,
  71                      OWeakObject                                     ,
  72                      DIRECT_INTERFACE(css::lang::XTypeProvider      ),
  73                      DIRECT_INTERFACE(css::frame::XDispatchProvider ),
  74                      DIRECT_INTERFACE(css::lang::XInitialization ),
  75                      DIRECT_INTERFACE(css::lang::XServiceInfo),
  76                      DIRECT_INTERFACE(css::frame::XNotifyingDispatch),
  77                      DIRECT_INTERFACE(css::frame::XDispatch         )
  78                    )
  79
  80 DEFINE_XTYPEPROVIDER_6( JobDispatch                   ,
  81                         css::lang::XTypeProvider      ,
  82                         css::frame::XDispatchProvider ,
  83                         css::frame::XNotifyingDispatch,
  84                         css::lang::XInitialization,
  85                         css::lang::XServiceInfo,
  86                         css::frame::XDispatch
  87                       )
  88
  89 DEFINE_XSERVICEINFO_MULTISERVICE( JobDispatch                   ,
  90                                   ::cppu::OWeakObject           ,
  91                                   SERVICENAME_PROTOCOLHANDLER   ,
  92                                   IMPLEMENTATIONNAME_JOBDISPATCH
  93                                 )
  94
  95 DEFINE_INIT_SERVICE( JobDispatch,
  96                      {
  97                          /*Attention
  98                              I think we don't need any mutex or lock here ... because we are called by our own static method impl_createInstance()
  99                              to create a new instance of this class by our own supported service factory.
 100                              see macro DEFINE_XSERVICEINFO_MULTISERVICE and "impl_initService()" for further informations!
 101                          */
 102                      }
 103                    )
 104
 105 //________________________________
 106 /**
 107     @short      standard ctor
 108     @descr      It initialize this new instance.
 109
 110     @param      xSMGR
 111                     reference to the uno service manager
 112 */
 113 JobDispatch::JobDispatch( /*IN*/ const css::uno::Reference< css::lang::XMultiServiceFactory >& xSMGR )
 114     : ThreadHelpBase(&Application::GetSolarMutex())
 115     , OWeakObject   (                             )
 116     , m_xSMGR       (xSMGR                        )
 117 {
 118 }
 119
 120 //________________________________
 121 /**
 122     @short  let this instance die
 123     @descr  We have to release all used ressources and free used memory.
 124 */
 125 JobDispatch::~JobDispatch()
 126 {
 127     // release all used ressources
 128     m_xSMGR  = css::uno::Reference< css::lang::XMultiServiceFactory >();
 129     m_xFrame = css::uno::Reference< css::frame::XFrame >();
 130 }
 131
 132 //________________________________
 133 /**
 134     @short  implementation of XInitalization
 135     @descr  A protocol handler can provide this functionality, if it wish to get additional informations
 136             about the context it runs. In this case the frame reference would be given by the outside code.
 137
 138     @param  lArguments
 139                 the list of initialization arguments
 140                 First parameter should be the frame reference we need.
 141 */
 142 void SAL_CALL JobDispatch::initialize( const css::uno::Sequence< css::uno::Any >& lArguments ) throw(css::uno::Exception       ,
 143                                                                                                      css::uno::RuntimeException)
 144 {
 145     /* SAFE { */
 146     WriteGuard aWriteLock(m_aLock);
 147
 148     for (int a=0; a<lArguments.getLength(); ++a)
 149     {
 150         if (a==0)
 151             lArguments[a] >>= m_xFrame;
 152     }
 153
 154     aWriteLock.unlock();
 155     /* } SAFE */
 156 }
 157
 158 //________________________________
 159 /**
 160     @short  implementation of XDispatchProvider::queryDispatches()
 161     @descr  Every protocol handler will be asked for his agreement, if an URL was queried
 162             for which this handler is registered. It's the chance for this handler to validate
 163             the given URL and return a dispatch object (may be itself) or not.
 164
 165     @param  aURL
 166                 the queried URL, which should be checked
 167
 168     @param  sTargetFrameName
 169                 describes the target frame, in which context this handler will be used
 170                 Is mostly set to "", "_self", "_blank", "_default" or a non special one
 171                 using SELF/CREATE as search flags.
 172
 173     @param  nSearchFlags
 174                 Can be SELF or CREATE only and are set only if sTargetFrameName isn't a special target
 175 */
 176 css::uno::Reference< css::frame::XDispatch > SAL_CALL JobDispatch::queryDispatch( /*IN*/ const css::util::URL&  aURL             ,
 177                                                                                   /*IN*/ const ::rtl::OUString& /*sTargetFrameName*/ ,
 178                                                                                   /*IN*/       sal_Int32        /*nSearchFlags*/     ) throw(css::uno::RuntimeException)
 179 {
 180     css::uno::Reference< css::frame::XDispatch > xDispatch;
 181
 182     JobURL aAnalyzedURL(aURL.Complete);
 183     if (aAnalyzedURL.isValid())
 184         xDispatch = css::uno::Reference< css::frame::XDispatch >( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );
 185
 186     return xDispatch;
 187 }
 188
 189 //________________________________
 190 /**
 191     @short  implementation of XDispatchProvider::queryDispatches()
 192     @descr  It's an optimized access for remote, so you can ask for
 193             multiple dispatch objects at the same time.
 194
 195     @param  lDescriptor
 196                 a list of queryDispatch() parameter
 197
 198     @return A list of corresponding dispatch objects.
 199             NULL references are not skipped. Every result
 200             match to one given descriptor item.
 201 */
 202 css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > SAL_CALL JobDispatch::queryDispatches( const css::uno::Sequence< css::frame::DispatchDescriptor >& lDescriptor ) throw(css::uno::RuntimeException)
 203 {
 204     // don't pack resulting list!
 205     sal_Int32 nCount = lDescriptor.getLength();
 206     css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > lDispatches(nCount);
 207
 208     for (sal_Int32 i=0; i<nCount; ++i)
 209         lDispatches[i] = queryDispatch( lDescriptor[i].FeatureURL  ,
 210                                         lDescriptor[i].FrameName   ,
 211                                         lDescriptor[i].SearchFlags );
 212     return lDispatches;
 213 }
 214
 215 //________________________________
 216 /**
 217     @short  implementation of XNotifyingDispatch::dispatchWithNotification()
 218     @descr  It creates the job service implementation and call execute on it.
 219             Further it starts the life time control of it. (important for async job)
 220             For synchonrous job we react for the returned result directly ... for asynchronous
 221             ones we do it later inside our callback method. But we use the same impl method
 222             doing that to share the code. (see impl_finishJob())
 223
 224             If a job is already running, (it can only occure for asynchronous jobs)
 225             don't start the same job a second time. Queue in the given dispatch parameter
 226             and return immediatly. If the current running job call us back, we will start this
 227             new dispatch request.
 228             If no job is running - queue the parameter too! But then start the new job immediatly.
 229             We have to queue it every time - because it hold us alive by ref count!
 230
 231     @param  aURL
 232                 describe the job(s), which should be started
 233
 234     @param  lArgs
 235                 optional arguments for this request
 236
 237     @param  xListener
 238                 an interested listener for possible results of this operation
 239 */
 240 void SAL_CALL JobDispatch::dispatchWithNotification( /*IN*/ const css::util::URL&                                             aURL      ,
 241                                                      /*IN*/ const css::uno::Sequence< css::beans::PropertyValue >&            lArgs     ,
 242                                                      /*IN*/ const css::uno::Reference< css::frame::XDispatchResultListener >& xListener ) throw(css::uno::RuntimeException)
 243 {
 244     JobURL aAnalyzedURL(aURL.Complete);
 245     if (aAnalyzedURL.isValid())
 246     {
 247         ::rtl::OUString sRequest;
 248         if (aAnalyzedURL.getEvent(sRequest))
 249             impl_dispatchEvent(sRequest, lArgs, xListener);
 250         else
 251         if (aAnalyzedURL.getService(sRequest))
 252             impl_dispatchService(sRequest, lArgs, xListener);
 253         else
 254         if (aAnalyzedURL.getAlias(sRequest))
 255             impl_dispatchAlias(sRequest, lArgs, xListener);
 256     }
 257 }
 258
 259 //________________________________
 260 /**
 261     @short  dispatch an event
 262     @descr  We search all registered jobs for this event and execute it.
 263             After doing so, we inform the given listener about the results.
 264             (There will be one notify for every executed job!)
 265
 266     @param  sEvent
 267                 the event, for which jobs can be registered
 268
 269     @param  lArgs
 270                 optional arguments for this request
 271                 Currently not used!
 272
 273     @param  xListener
 274                 an interested listener for possible results of this operation
 275 */
 276 void JobDispatch::impl_dispatchEvent( /*IN*/ const ::rtl::OUString&                                            sEvent    ,
 277                                       /*IN*/ const css::uno::Sequence< css::beans::PropertyValue >&            lArgs     ,
 278                                       /*IN*/ const css::uno::Reference< css::frame::XDispatchResultListener >& xListener )
 279 {
 280     // get list of all enabled jobs
 281     // The called static helper methods read it from the configuration and
 282     // filter disabled jobs using it's time stamp values.
 283     /* SAFE { */
 284     ReadGuard aReadLock(m_aLock);
 285     css::uno::Sequence< ::rtl::OUString > lJobs = JobData::getEnabledJobsForEvent(m_xSMGR, sEvent);
 286     aReadLock.unlock();
 287     /* } SAFE */
 288
 289     css::uno::Reference< css::frame::XDispatchResultListener > xThis( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );
 290
 291     // no jobs ... no execution
 292     // But a may given listener will know something ...
 293     // I think this operaton was finished successfully.
 294     // It's not realy an error, if no registered jobs could be located.
 295     if (lJobs.getLength()<1 && xListener.is())
 296     {
 297         css::frame::DispatchResultEvent aEvent;
 298         aEvent.Source = xThis;
 299         aEvent.State  = css::frame::DispatchResultState::SUCCESS;
 300         xListener->dispatchFinished(aEvent);
 301         return;
 302     }
 303
 304     // Step over all found jobs and execute it
 305     for (int j=0; j<lJobs.getLength(); ++j)
 306     {
 307         /* SAFE { */
 308         aReadLock.lock();
 309
 310         JobData aCfg(m_xSMGR);
 311         aCfg.setEvent(sEvent, lJobs[j]);
 312         aCfg.setEnvironment(JobData::E_DISPATCH);
 313
 314         /*Attention!
 315             Jobs implements interfaces and dies by ref count!
 316             And freeing of such uno object is done by uno itself.
 317             So we have to use dynamic memory everytimes.
 318          */
 319         Job* pJob = new Job(m_xSMGR, m_xFrame);
 320         css::uno::Reference< css::uno::XInterface > xJob(static_cast< ::cppu::OWeakObject* >(pJob), css::uno::UNO_QUERY);
 321         pJob->setJobData(aCfg);
 322
 323         aReadLock.unlock();
 324         /* } SAFE */
 325
 326         // Special mode for listener.
 327         // We dont notify it directly here. We delegate that
 328         // to the job implementation. But we must set ourself there too.
 329         // Because this job must fake the source adress of the event.
 330         // Otherwhise the listener may will ignore it.
 331         if (xListener.is())
 332             pJob->setDispatchResultFake(xListener, xThis);
 333         pJob->execute(Converter::convert_seqPropVal2seqNamedVal(lArgs));
 334     }
 335 }
 336
 337 //________________________________
 338 /**
 339     @short  dispatch a service
 340     @descr  We use the given name only to create and if possible to initialize
 341             it as an uno service. It can be usefully for creating (caching?)
 342             of e.g. one instance services.
 343
 344     @param  sService
 345                 the uno implementation or service name of the job, which should be instanciated
 346
 347     @param  lArgs
 348                 optional arguments for this request
 349                 Currently not used!
 350
 351     @param  xListener
 352                 an interested listener for possible results of this operation
 353 */
 354 void JobDispatch::impl_dispatchService( /*IN*/ const ::rtl::OUString&                                            sService  ,
 355                                         /*IN*/ const css::uno::Sequence< css::beans::PropertyValue >&            lArgs     ,
 356                                         /*IN*/ const css::uno::Reference< css::frame::XDispatchResultListener >& xListener )
 357 {
 358     /* SAFE { */
 359     ReadGuard aReadLock(m_aLock);
 360
 361     JobData aCfg(m_xSMGR);
 362     aCfg.setService(sService);
 363     aCfg.setEnvironment(JobData::E_DISPATCH);
 364
 365     /*Attention!
 366         Jobs implements interfaces and dies by ref count!
 367         And freeing of such uno object is done by uno itself.
 368         So we have to use dynamic memory everytimes.
 369      */
 370     Job* pJob = new Job(m_xSMGR, m_xFrame);
 371     css::uno::Reference< css::uno::XInterface > xJob(static_cast< ::cppu::OWeakObject* >(pJob), css::uno::UNO_QUERY);
 372     pJob->setJobData(aCfg);
 373
 374     aReadLock.unlock();
 375     /* } SAFE */
 376
 377     css::uno::Reference< css::frame::XDispatchResultListener > xThis( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );
 378
 379     // Special mode for listener.
 380     // We dont notify it directly here. We delegate that
 381     // to the job implementation. But we must set ourself there too.
 382     // Because this job must fake the source adress of the event.
 383     // Otherwhise the listener may will ignore it.
 384     if (xListener.is())
 385         pJob->setDispatchResultFake(xListener, xThis);
 386     pJob->execute(Converter::convert_seqPropVal2seqNamedVal(lArgs));
 387 }
 388
 389 //________________________________
 390 /**
 391     @short  dispatch an alias
 392     @descr  We use this alias to locate a job inside the configuration
 393             and execute it. Further we inform the given listener about the results.
 394
 395     @param  sAlias
 396                 the alias name of the configured job
 397
 398     @param  lArgs
 399                 optional arguments for this request
 400                 Currently not used!
 401
 402     @param  xListener
 403                 an interested listener for possible results of this operation
 404 */
 405 void JobDispatch::impl_dispatchAlias( /*IN*/ const ::rtl::OUString&                                            sAlias    ,
 406                                       /*IN*/ const css::uno::Sequence< css::beans::PropertyValue >&            lArgs     ,
 407                                       /*IN*/ const css::uno::Reference< css::frame::XDispatchResultListener >& xListener )
 408 {
 409     /* SAFE { */
 410     ReadGuard aReadLock(m_aLock);
 411
 412     JobData aCfg(m_xSMGR);
 413     aCfg.setAlias(sAlias);
 414     aCfg.setEnvironment(JobData::E_DISPATCH);
 415
 416     /*Attention!
 417         Jobs implements interfaces and dies by ref count!
 418         And freeing of such uno object is done by uno itself.
 419         So we have to use dynamic memory everytimes.
 420      */
 421     Job* pJob = new Job(m_xSMGR, m_xFrame);
 422     css::uno::Reference< css::uno::XInterface > xJob(static_cast< ::cppu::OWeakObject* >(pJob), css::uno::UNO_QUERY);
 423     pJob->setJobData(aCfg);
 424
 425     aReadLock.unlock();
 426     /* } SAFE */
 427
 428     css::uno::Reference< css::frame::XDispatchResultListener > xThis( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );
 429
 430     // Special mode for listener.
 431     // We dont notify it directly here. We delegate that
 432     // to the job implementation. But we must set ourself there too.
 433     // Because this job must fake the source adress of the event.
 434     // Otherwhise the listener may will ignore it.
 435     if (xListener.is())
 436         pJob->setDispatchResultFake(xListener, xThis);
 437     pJob->execute(Converter::convert_seqPropVal2seqNamedVal(lArgs));
 438 }
 439
 440 //________________________________
 441 /**
 442     @short  implementation of XDispatch::dispatch()
 443     @descr  Because the methods dispatch() and dispatchWithNotification() are different in her parameters
 444             only, we can forward this request to dispatchWithNotification() by using an empty listener!
 445
 446     @param  aURL
 447                 describe the job(s), which should be started
 448
 449     @param  lArgs
 450                 optional arguments for this request
 451
 452     @see    dispatchWithNotification()
 453 */
 454 void SAL_CALL JobDispatch::dispatch( /*IN*/ const css::util::URL&                                  aURL  ,
 455                                      /*IN*/ const css::uno::Sequence< css::beans::PropertyValue >& lArgs ) throw(css::uno::RuntimeException)
 456 {
 457     dispatchWithNotification(aURL, lArgs, css::uno::Reference< css::frame::XDispatchResultListener >());
 458 }
 459
 460 //________________________________
 461 /**
 462     @short  not supported
 463 */
 464 void SAL_CALL JobDispatch::addStatusListener( /*IN*/ const css::uno::Reference< css::frame::XStatusListener >&,
 465                                               /*IN*/ const css::util::URL&                                      ) throw(css::uno::RuntimeException)
 466 {
 467 }
 468
 469 //________________________________
 470 /**
 471     @short  not supported
 472 */
 473 void SAL_CALL JobDispatch::removeStatusListener( /*IN*/ const css::uno::Reference< css::frame::XStatusListener >&,
 474                                                  /*IN*/ const css::util::URL&                                          ) throw(css::uno::RuntimeException)
 475 {
 476 }
 477
 478 } // namespace framework