jobexecutor.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */
 
#include <jobs/job.hxx>
#include <jobs/configaccess.hxx>
#include <classes/converter.hxx>
 
#include <helper/mischelper.hxx>
 
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/container/XContainer.hpp>
#include <com/sun/star/frame/ModuleManager.hpp>
#include <com/sun/star/task/XJobExecutor.hpp>
#include <com/sun/star/container/XContainerListener.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/document/XEventListener.hpp>
 
#include <comphelper/compbase.hxx>
#include <cppuhelper/supportsservice.hxx>
#include <unotools/configmgr.hxx>
#include <unotools/configpaths.hxx>
#include <rtl/ref.hxx>
#include <sal/log.hxx>
#include <vcl/svapp.hxx>
 
using namespace framework;
 
namespace {
 
typedef comphelper::WeakComponentImplHelper<
          css::lang::XServiceInfo
        , css::task::XJobExecutor
        , css::container::XContainerListener // => lang.XEventListener
        , css::document::XEventListener >
    Base;
 
class JobExecutor : public Base
{
private:
 
    css::uno::Reference< css::uno::XComponentContext > m_xContext;
 
    std::vector<OUString> m_lEvents;
 
    ConfigAccess m_aConfig;
 
    css::uno::Reference<css::container::XContainerListener> m_xConfigListener;
 
    virtual void disposing(std::unique_lock<std::mutex>& rGuard) final override;
 
public:
 
    explicit JobExecutor(const css::uno::Reference< css::uno::XComponentContext >& xContext);
    virtual ~JobExecutor() override;
 
    virtual OUString SAL_CALL getImplementationName() override
    {
        return "com.sun.star.comp.framework.JobExecutor";
    }
 
    virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override
    {
        return cppu::supportsService(this, ServiceName);
    }
 
    virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
    {
        return {"com.sun.star.task.JobExecutor"};
    }
 
    // task.XJobExecutor
    virtual void SAL_CALL trigger( const OUString& sEvent ) override;
 
    void initListeners();
 
    // document.XEventListener
    virtual void SAL_CALL notifyEvent( const css::document::EventObject& aEvent ) override;
 
    // container.XContainerListener
    virtual void SAL_CALL elementInserted( const css::container::ContainerEvent& aEvent ) override;
    virtual void SAL_CALL elementRemoved ( const css::container::ContainerEvent& aEvent ) override;
    virtual void SAL_CALL elementReplaced( const css::container::ContainerEvent& aEvent ) override;
 
    // lang.XEventListener
    virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) override;
};
 
JobExecutor::JobExecutor( /*IN*/ const css::uno::Reference< css::uno::XComponentContext >& xContext )
    : m_xContext          (xContext                                                        )
    , m_aConfig           (xContext, "/org.openoffice.Office.Jobs/Events")
{
}
 
void JobExecutor::initListeners()
{
    if (utl::ConfigManager::IsFuzzing())
        return;
 
    // read the list of all currently registered events inside configuration.
    // e.g. "/org.openoffice.Office.Jobs/Events/<event name>"
    // We need it later to check if an incoming event request can be executed successfully
    // or must be rejected. It's an optimization! Of course we must implement updating of this
    // list too ... Be listener at the configuration.
 
    m_aConfig.open(ConfigAccess::E_READONLY);
    if (m_aConfig.getMode() != ConfigAccess::E_READONLY)
        return;
 
    css::uno::Reference< css::container::XNameAccess > xRegistry(
            m_aConfig.cfg(), css::uno::UNO_QUERY);
    if (xRegistry.is())
        m_lEvents = Converter::convert_seqOUString2OUStringList(
                xRegistry->getElementNames());
 
    css::uno::Reference< css::container::XContainer > xNotifier(
            m_aConfig.cfg(), css::uno::UNO_QUERY);
    if (xNotifier.is())
    {
        m_xConfigListener = new WeakContainerListener(this);
        xNotifier->addContainerListener(m_xConfigListener);
    }
 
    // don't close cfg here!
    // It will be done inside disposing ...
}
 
JobExecutor::~JobExecutor()
{
    std::unique_lock g(m_aMutex);
    disposing(g);
}
 
void JobExecutor::disposing(std::unique_lock<std::mutex>& /*rGuard*/) {
    css::uno::Reference<css::container::XContainer> notifier;
    css::uno::Reference<css::container::XContainerListener> listener;
    if (m_aConfig.getMode() != ConfigAccess::E_CLOSED) {
        notifier.set(m_aConfig.cfg(), css::uno::UNO_QUERY);
        listener = m_xConfigListener;
        m_aConfig.close();
    }
    m_xConfigListener.clear();
    if (notifier.is()) {
        notifier->removeContainerListener(listener);
    }
}
 
void SAL_CALL JobExecutor::trigger( const OUString& sEvent )
{
    SAL_INFO( "fwk", "JobExecutor::trigger()");
 
    /* SAFE */
    {
        std::unique_lock g(m_aMutex);
 
        // Optimization!
        // Check if the given event name exist inside configuration and reject wrong requests.
        // This optimization suppress using of the cfg api for getting event and job descriptions ...
        if (std::find(m_lEvents.begin(), m_lEvents.end(), sEvent) == m_lEvents.end())
            return;
 
    } /* SAFE */
 
    // get list of all enabled jobs
    // The called static helper methods read it from the configuration and
    // filter disabled jobs using it's time stamp values.
    std::vector< OUString > lJobs = JobData::getEnabledJobsForEvent(m_xContext, sEvent);
 
    // step over all enabled jobs and execute it
    size_t c = lJobs.size();
    for (size_t j=0; j<c; ++j)
    {
        JobData aCfg(m_xContext);
        aCfg.setEvent(sEvent, lJobs[j]);
        aCfg.setEnvironment(JobData::E_EXECUTION);
 
        /*Attention!
            Jobs implements interfaces and dies by ref count!
            And freeing of such uno object is done by uno itself.
            So we have to use dynamic memory everytimes.
         */
        rtl::Reference<Job> pJob = new Job(m_xContext, css::uno::Reference< css::frame::XFrame >());
        pJob->setJobData(aCfg);
 
        pJob->execute(css::uno::Sequence< css::beans::NamedValue >());
    }
}
 
void SAL_CALL JobExecutor::notifyEvent( const css::document::EventObject& aEvent )
{
    static constexpr OUStringLiteral EVENT_ON_DOCUMENT_OPENED(u"onDocumentOpened");   // Job UI  event : OnNew    or OnLoad
    static constexpr OUStringLiteral EVENT_ON_DOCUMENT_ADDED(u"onDocumentAdded");     // Job API event : OnCreate or OnLoadFinished
 
    OUString aModuleIdentifier;
    ::std::vector< JobData::TJob2DocEventBinding > lJobs;
 
    // Optimization!
    // Check if the given event name exist inside configuration and reject wrong requests.
    // This optimization suppress using of the cfg api for getting event and job descriptions.
    // see using of m_lEvents.find() below ...
 
    // retrieve event context from event source
    try
    {
        aModuleIdentifier = css::frame::ModuleManager::create( m_xContext )->identify( aEvent.Source );
    }
    catch( const css::uno::Exception& )
    {}
 
    /* SAFE */
    {
        std::unique_lock g(m_aMutex);
 
        // Special feature: If the events "OnNew" or "OnLoad" occurs - we generate our own event "onDocumentOpened".
        if (
            (aEvent.EventName == "OnNew") ||
            (aEvent.EventName == "OnLoad")
           )
        {
            if (std::find(m_lEvents.begin(), m_lEvents.end(), EVENT_ON_DOCUMENT_OPENED) != m_lEvents.end())
                JobData::appendEnabledJobsForEvent(m_xContext, EVENT_ON_DOCUMENT_OPENED, lJobs);
        }
 
        // Special feature: If the events "OnCreate" or "OnLoadFinished" occurs - we generate our own event "onDocumentAdded".
        if (
            (aEvent.EventName == "OnCreate") ||
            (aEvent.EventName == "OnLoadFinished")
           )
        {
            if (std::find(m_lEvents.begin(), m_lEvents.end(), EVENT_ON_DOCUMENT_ADDED) != m_lEvents.end())
                JobData::appendEnabledJobsForEvent(m_xContext, EVENT_ON_DOCUMENT_ADDED, lJobs);
        }
 
        // Add all jobs for "real" notified event too .-)
        if (std::find(m_lEvents.begin(), m_lEvents.end(), aEvent.EventName) != m_lEvents.end())
            JobData::appendEnabledJobsForEvent(m_xContext, aEvent.EventName, lJobs);
    } /* SAFE */
 
    // step over all enabled jobs and execute it
    for (auto const& lJob : lJobs)
    {
        rtl::Reference<Job> pJob;
 
        const JobData::TJob2DocEventBinding& rBinding = lJob;
 
        JobData aCfg(m_xContext);
        aCfg.setEvent(rBinding.m_sDocEvent, rBinding.m_sJobName);
        aCfg.setEnvironment(JobData::E_DOCUMENTEVENT);
 
        if (!aCfg.hasCorrectContext(aModuleIdentifier))
            continue;
 
        /*Attention!
            Jobs implements interfaces and dies by ref count!
            And freeing of such uno object is done by uno itself.
            So we have to use dynamic memory everytimes.
         */
        css::uno::Reference< css::frame::XModel > xModel(aEvent.Source, css::uno::UNO_QUERY);
        pJob = new Job(m_xContext, xModel);
        pJob->setJobData(aCfg);
 
        pJob->execute(css::uno::Sequence< css::beans::NamedValue >());
    }
}
 
void SAL_CALL JobExecutor::elementInserted( const css::container::ContainerEvent& aEvent )
{
    OUString sValue;
    if (aEvent.Accessor >>= sValue)
    {
        OUString sEvent = ::utl::extractFirstFromConfigurationPath(sValue);
        if (!sEvent.isEmpty())
        {
            std::vector<OUString>::iterator pEvent = std::find(m_lEvents.begin(), m_lEvents.end(), sEvent);
            if (pEvent == m_lEvents.end())
                m_lEvents.push_back(sEvent);
        }
    }
}
 
void SAL_CALL JobExecutor::elementRemoved ( const css::container::ContainerEvent& aEvent )
{
    OUString sValue;
    if (aEvent.Accessor >>= sValue)
    {
        OUString sEvent = ::utl::extractFirstFromConfigurationPath(sValue);
        if (!sEvent.isEmpty())
        {
            std::vector<OUString>::iterator pEvent = std::find(m_lEvents.begin(), m_lEvents.end(), sEvent);
            if (pEvent != m_lEvents.end())
                m_lEvents.erase(pEvent);
        }
    }
}
 
void SAL_CALL JobExecutor::elementReplaced( const css::container::ContainerEvent& )
{
    // I'm not interested on changed items :-)
}
 
void SAL_CALL JobExecutor::disposing( const css::lang::EventObject& aEvent )
{
    /* SAFE { */
    std::unique_lock g(m_aMutex);
    css::uno::Reference< css::uno::XInterface > xCFG(m_aConfig.cfg(), css::uno::UNO_QUERY);
    if (
        (xCFG                == aEvent.Source        ) &&
        (m_aConfig.getMode() != ConfigAccess::E_CLOSED)
       )
    {
        m_aConfig.close();
    }
    /* } SAFE */
}
 
}
 
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
com_sun_star_comp_framework_JobExecutor_get_implementation(
    css::uno::XComponentContext *context,
    css::uno::Sequence<css::uno::Any> const &)
{
    rtl::Reference<JobExecutor> xJobExec = new JobExecutor(context);
    // 2nd phase initialization needed
    xJobExec->initListeners();
    return cppu::acquire(xJobExec.get());
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */