desktop/source/deployment/gui/dp_gui_extensioncmdqueue.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <com/sun/star/beans/NamedValue.hpp>
  23
  24 #include <com/sun/star/deployment/DependencyException.hpp>
  25 #include <com/sun/star/deployment/LicenseException.hpp>
  26 #include <com/sun/star/deployment/VersionException.hpp>
  27 #include <com/sun/star/deployment/InstallException.hpp>
  28 #include <com/sun/star/deployment/PlatformException.hpp>
  29
  30 #include <com/sun/star/deployment/ui/LicenseDialog.hpp>
  31 #include <com/sun/star/deployment/DeploymentException.hpp>
  32 #include <com/sun/star/deployment/XPackage.hpp>
  33
  34 #include <com/sun/star/task/InteractionHandler.hpp>
  35 #include <com/sun/star/task/XAbortChannel.hpp>
  36 #include <com/sun/star/task/XInteractionAbort.hpp>
  37 #include <com/sun/star/task/XInteractionApprove.hpp>
  38
  39 #include <com/sun/star/ucb/CommandAbortedException.hpp>
  40 #include <com/sun/star/ucb/CommandFailedException.hpp>
  41 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  42
  43 #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
  44
  45 #include <com/sun/star/uno/Reference.hxx>
  46 #include <com/sun/star/uno/Sequence.hxx>
  47 #include <com/sun/star/uno/TypeClass.hpp>
  48 #include <o3tl/any.hxx>
  49 #include <osl/diagnose.h>
  50 #include <rtl/ref.hxx>
  51 #include <rtl/ustring.hxx>
  52 #include <sal/types.h>
  53 #include <salhelper/thread.hxx>
  54 #include <ucbhelper/content.hxx>
  55 #include <cppuhelper/exc_hlp.hxx>
  56 #include <cppuhelper/implbase.hxx>
  57 #include <comphelper/anytostring.hxx>
  58 #include <utility>
  59 #include <vcl/svapp.hxx>
  60 #include <vcl/weld.hxx>
  61
  62 #include "dp_gui_extensioncmdqueue.hxx"
  63 #include "dp_gui_dependencydialog.hxx"
  64 #include "dp_gui_dialog2.hxx"
  65 #include <dp_shared.hxx>
  66 #include <strings.hrc>
  67 #include "dp_gui_theextmgr.hxx"
  68 #include "dp_gui_updatedialog.hxx"
  69 #include "dp_gui_updateinstalldialog.hxx"
  70 #include <dp_dependencies.hxx>
  71 #include <dp_misc.h>
  72 #include <dp_identifier.hxx>
  73 #include <dp_version.hxx>
  74
  75 #include <condition_variable>
  76 #include <queue>
  77 #include <memory>
  78 #include <mutex>
  79
  80 #ifdef _WIN32
  81 #include <o3tl/safeCoInitUninit.hxx>
  82 #endif
  83
  84
  85 using namespace ::com::sun::star;
  86
  87 namespace {
  88
  89 OUString getVersion( OUString const & sVersion )
  90 {
  91     return ( sVersion.isEmpty() ) ? u"0"_ustr : sVersion;
  92 }
  93
  94 OUString getVersion( const uno::Reference< deployment::XPackage > &rPackage )
  95 {
  96     return getVersion( rPackage->getVersion());
  97 }
  98 }
  99
 100
 101 namespace dp_gui {
 102
 103 namespace {
 104
 105 class ProgressCmdEnv
 106     : public ::cppu::WeakImplHelper< ucb::XCommandEnvironment,
 107                                       task::XInteractionHandler,
 108                                       ucb::XProgressHandler >
 109 {
 110     uno::Reference< task::XInteractionHandler2> m_xHandler;
 111     uno::Reference< uno::XComponentContext > m_xContext;
 112
 113     DialogHelper*   m_pDialogHelper;
 114     OUString        m_sTitle;
 115     bool            m_bWarnUser;
 116     sal_Int32       m_nCurrentProgress;
 117
 118     void updateProgress();
 119
 120     /// @throws uno::RuntimeException
 121     void update_( uno::Any const & Status );
 122
 123 public:
 124     /** When param bAskWhenInstalling = true, then the user is asked if he
 125     agrees to install this extension. In case this extension is already installed
 126     then the user is also notified and asked if he wants to replace that existing
 127     extension. In first case an interaction request with an InstallException
 128     will be handled and in the second case a VersionException will be handled.
 129     */
 130
 131     ProgressCmdEnv( uno::Reference< uno::XComponentContext > xContext,
 132                     DialogHelper* pDialogHelper,
 133                     OUString aTitle )
 134         : m_xContext(std::move( xContext ))
 135         , m_pDialogHelper( pDialogHelper )
 136         , m_sTitle(std::move( aTitle ))
 137         , m_bWarnUser( false )
 138         , m_nCurrentProgress(0)
 139         {}
 140
 141     weld::Window* activeDialog() { return m_pDialogHelper ? m_pDialogHelper->getFrameWeld() : nullptr; }
 142
 143     void startProgress();
 144     void stopProgress();
 145     void progressSection( const OUString &rText,
 146                           const uno::Reference< task::XAbortChannel > &xAbortChannel );
 147     void setWarnUser( bool bNewVal ) { m_bWarnUser = bNewVal; }
 148
 149     // XCommandEnvironment
 150     virtual uno::Reference< task::XInteractionHandler > SAL_CALL getInteractionHandler() override;
 151     virtual uno::Reference< ucb::XProgressHandler > SAL_CALL getProgressHandler() override;
 152
 153     // XInteractionHandler
 154     virtual void SAL_CALL handle( uno::Reference< task::XInteractionRequest > const & xRequest ) override;
 155
 156     // XProgressHandler
 157     virtual void SAL_CALL push( uno::Any const & Status ) override;
 158     virtual void SAL_CALL update( uno::Any const & Status ) override;
 159     virtual void SAL_CALL pop() override;
 160 };
 161
 162
 163 struct ExtensionCmd
 164 {
 165     enum E_CMD_TYPE { ADD, ENABLE, DISABLE, REMOVE, CHECK_FOR_UPDATES, ACCEPT_LICENSE };
 166
 167     E_CMD_TYPE  m_eCmdType;
 168     bool        m_bWarnUser;
 169     OUString    m_sExtensionURL;
 170     OUString    m_sRepository;
 171     uno::Reference< deployment::XPackage > m_xPackage;
 172     std::vector< uno::Reference< deployment::XPackage > >        m_vExtensionList;
 173
 174     ExtensionCmd( const E_CMD_TYPE eCommand,
 175                   OUString aExtensionURL,
 176                   OUString aRepository,
 177                   const bool bWarnUser )
 178         : m_eCmdType( eCommand ),
 179           m_bWarnUser( bWarnUser ),
 180           m_sExtensionURL(std::move( aExtensionURL )),
 181           m_sRepository(std::move( aRepository )) {};
 182     ExtensionCmd( const E_CMD_TYPE eCommand,
 183                   uno::Reference< deployment::XPackage > xPackage )
 184         : m_eCmdType( eCommand ),
 185           m_bWarnUser( false ),
 186           m_xPackage(std::move( xPackage )) {};
 187     ExtensionCmd( const E_CMD_TYPE eCommand,
 188                 std::vector<uno::Reference<deployment::XPackage > >&&vExtensionList )
 189         : m_eCmdType( eCommand ),
 190           m_bWarnUser( false ),
 191           m_vExtensionList( std::move(vExtensionList) ) {};
 192 };
 193
 194 }
 195
 196 typedef std::shared_ptr< ExtensionCmd > TExtensionCmd;
 197
 198
 199 class ExtensionCmdQueue::Thread: public salhelper::Thread
 200 {
 201 public:
 202     Thread( DialogHelper *pDialogHelper,
 203             TheExtensionManager *pManager,
 204             uno::Reference< uno::XComponentContext > xContext );
 205
 206     void addExtension( const OUString &rExtensionURL,
 207                        const OUString &rRepository,
 208                        const bool bWarnUser );
 209     void removeExtension( const uno::Reference< deployment::XPackage > &rPackage );
 210     void enableExtension( const uno::Reference< deployment::XPackage > &rPackage,
 211                           const bool bEnable );
 212     void checkForUpdates( std::vector<uno::Reference<deployment::XPackage > > && vExtensionList );
 213     void acceptLicense( const uno::Reference< deployment::XPackage > &rPackage );
 214     void stop();
 215     bool isBusy();
 216
 217 private:
 218     virtual ~Thread() override;
 219
 220     virtual void execute() override;
 221
 222     void _insert(const TExtensionCmd& rExtCmd);
 223
 224     void _addExtension( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
 225                         const OUString &rPackageURL,
 226                         const OUString &rRepository,
 227                         const bool bWarnUser );
 228     void _removeExtension( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
 229                            const uno::Reference< deployment::XPackage > &xPackage );
 230     void _enableExtension( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
 231                            const uno::Reference< deployment::XPackage > &xPackage );
 232     void _disableExtension( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
 233                             const uno::Reference< deployment::XPackage > &xPackage );
 234     void _checkForUpdates( std::vector<uno::Reference<deployment::XPackage > > &&vExtensionList );
 235     void _acceptLicense( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
 236                            const uno::Reference< deployment::XPackage > &xPackage );
 237
 238     enum Input { NONE, START, STOP };
 239
 240     uno::Reference< uno::XComponentContext > m_xContext;
 241     std::queue< TExtensionCmd >              m_queue;
 242
 243     DialogHelper *m_pDialogHelper;
 244     TheExtensionManager *m_pManager;
 245
 246     const OUString   m_sEnablingPackages;
 247     const OUString   m_sDisablingPackages;
 248     const OUString   m_sAddingPackages;
 249     const OUString   m_sRemovingPackages;
 250     const OUString   m_sDefaultCmd;
 251     const OUString   m_sAcceptLicense;
 252     std::condition_variable m_wakeup;
 253     std::mutex       m_mutex;
 254     Input            m_eInput;
 255     bool             m_bStopped;
 256     bool             m_bWorking;
 257 };
 258
 259
 260 void ProgressCmdEnv::startProgress()
 261 {
 262     m_nCurrentProgress = 0;
 263
 264     if ( m_pDialogHelper )
 265         m_pDialogHelper->showProgress( true );
 266 }
 267
 268
 269 void ProgressCmdEnv::stopProgress()
 270 {
 271     if ( m_pDialogHelper )
 272         m_pDialogHelper->showProgress( false );
 273 }
 274
 275
 276 void ProgressCmdEnv::progressSection( const OUString &rText,
 277                                       const uno::Reference< task::XAbortChannel > &xAbortChannel )
 278 {
 279     m_nCurrentProgress = 0;
 280     if ( m_pDialogHelper )
 281     {
 282         m_pDialogHelper->updateProgress( rText, xAbortChannel );
 283         m_pDialogHelper->updateProgress( 5 );
 284     }
 285 }
 286
 287
 288 void ProgressCmdEnv::updateProgress()
 289 {
 290     tools::Long nProgress = ((m_nCurrentProgress*5) % 100) + 5;
 291     if ( m_pDialogHelper )
 292         m_pDialogHelper->updateProgress( nProgress );
 293 }
 294
 295 // XCommandEnvironment
 296
 297 uno::Reference< task::XInteractionHandler > ProgressCmdEnv::getInteractionHandler()
 298 {
 299     return this;
 300 }
 301
 302
 303 uno::Reference< ucb::XProgressHandler > ProgressCmdEnv::getProgressHandler()
 304 {
 305     return this;
 306 }
 307
 308
 309 // XInteractionHandler
 310
 311 void ProgressCmdEnv::handle( uno::Reference< task::XInteractionRequest > const & xRequest )
 312 {
 313     uno::Any request( xRequest->getRequest() );
 314     OSL_ASSERT( request.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 315     dp_misc::TRACE( "[dp_gui_cmdenv.cxx] incoming request:\n"
 316         + ::comphelper::anyToString(request) + "\n");
 317
 318     lang::WrappedTargetException wtExc;
 319     deployment::DependencyException depExc;
 320     deployment::LicenseException licExc;
 321     deployment::VersionException verExc;
 322     deployment::InstallException instExc;
 323     deployment::PlatformException platExc;
 324
 325     // selections:
 326     bool approve = false;
 327     bool abort = false;
 328
 329     if (request >>= wtExc) {
 330         // handable deployment error signalled, e.g.
 331         // bundle item registration failed, notify cause only:
 332         uno::Any cause;
 333         deployment::DeploymentException dpExc;
 334         if (wtExc.TargetException >>= dpExc)
 335             cause = dpExc.Cause;
 336         else {
 337             ucb::CommandFailedException cfExc;
 338             if (wtExc.TargetException >>= cfExc)
 339                 cause = cfExc.Reason;
 340             else
 341                 cause = wtExc.TargetException;
 342         }
 343         update_( cause );
 344
 345         // ignore intermediate errors of legacy packages, i.e.
 346         // former pkgchk behaviour:
 347         const uno::Reference< deployment::XPackage > xPackage( wtExc.Context, uno::UNO_QUERY );
 348         OSL_ASSERT( xPackage.is() );
 349         if ( xPackage.is() )
 350         {
 351             const uno::Reference< deployment::XPackageTypeInfo > xPackageType( xPackage->getPackageType() );
 352             OSL_ASSERT( xPackageType.is() );
 353             if (xPackageType.is())
 354             {
 355                 approve = ( xPackage->isBundle() &&
 356                             xPackageType->getMediaType().match(
 357                                "application/vnd.sun.star.legacy-package-bundle" ));
 358             }
 359         }
 360         abort = !approve;
 361     }
 362     else if (request >>= depExc)
 363     {
 364         std::vector< OUString > deps;
 365         deps.reserve(depExc.UnsatisfiedDependencies.getLength());
 366         for (auto const& i : depExc.UnsatisfiedDependencies)
 367         {
 368             deps.push_back( dp_misc::Dependencies::getErrorText(i) );
 369         }
 370         {
 371             SolarMutexGuard guard;
 372             if (m_pDialogHelper)
 373                 m_pDialogHelper->incBusy();
 374             DependencyDialog aDlg(activeDialog(), deps);
 375             short n = aDlg.run();
 376             if (m_pDialogHelper)
 377                 m_pDialogHelper->decBusy();
 378             // Distinguish between closing the dialog and programmatically
 379             // canceling the dialog (headless VCL):
 380             approve = n == RET_OK
 381                 || (n == RET_CANCEL && !Application::IsDialogCancelEnabled());
 382         }
 383     }
 384     else if (request >>= licExc)
 385     {
 386         SolarMutexGuard guard;
 387
 388         weld::Window *pTopLevel = activeDialog();
 389         if (m_pDialogHelper)
 390             m_pDialogHelper->incBusy();
 391         uno::Reference< ui::dialogs::XExecutableDialog > xDialog(
 392             deployment::ui::LicenseDialog::create(
 393             m_xContext, pTopLevel ? pTopLevel->GetXWindow() : nullptr,
 394             licExc.ExtensionName, licExc.Text ) );
 395         sal_Int16 res = xDialog->execute();
 396         if (m_pDialogHelper)
 397             m_pDialogHelper->decBusy();
 398         if ( res == ui::dialogs::ExecutableDialogResults::CANCEL )
 399             abort = true;
 400         else if ( res == ui::dialogs::ExecutableDialogResults::OK )
 401             approve = true;
 402         else
 403         {
 404             OSL_ASSERT(false);
 405         }
 406     }
 407     else if (request >>= verExc)
 408     {
 409         TranslateId id;
 410         switch (dp_misc::compareVersions(
 411                     verExc.NewVersion, verExc.Deployed->getVersion() ))
 412         {
 413         case dp_misc::LESS:
 414             id = RID_STR_WARNING_VERSION_LESS;
 415             break;
 416         case dp_misc::EQUAL:
 417             id = RID_STR_WARNING_VERSION_EQUAL;
 418             break;
 419         default: // dp_misc::GREATER
 420             id = RID_STR_WARNING_VERSION_GREATER;
 421             break;
 422         }
 423         OSL_ASSERT( verExc.Deployed.is() );
 424         bool bEqualNames = verExc.NewDisplayName ==
 425             verExc.Deployed->getDisplayName();
 426         {
 427             SolarMutexGuard guard;
 428
 429             if (m_pDialogHelper)
 430                 m_pDialogHelper->incBusy();
 431
 432             std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(activeDialog(),
 433                                                       VclMessageType::Warning, VclButtonsType::OkCancel, DpResId(id)));
 434             OUString s;
 435             if (bEqualNames)
 436             {
 437                 s = xBox->get_primary_text();
 438             }
 439             else if (id != RID_STR_WARNING_VERSION_EQUAL)
 440             {
 441                 //hypothetical: requires two instances of an extension with the same
 442                 //version to have different display names. Probably the developer forgot
 443                 //to change the version.
 444                 s = DpResId(RID_STR_WARNINGBOX_VERSION_EQUAL_DIFFERENT_NAMES);
 445             }
 446             else if (id != RID_STR_WARNING_VERSION_LESS)
 447             {
 448                 s = DpResId(RID_STR_WARNINGBOX_VERSION_LESS_DIFFERENT_NAMES);
 449             }
 450             else if (id != RID_STR_WARNING_VERSION_GREATER)
 451             {
 452                s = DpResId(RID_STR_WARNINGBOX_VERSION_GREATER_DIFFERENT_NAMES);
 453             }
 454             s = s.replaceAll("$NAME", verExc.NewDisplayName);
 455             s = s.replaceAll("$OLDNAME", verExc.Deployed->getDisplayName());
 456             s = s.replaceAll("$NEW", getVersion(verExc.NewVersion));
 457             s = s.replaceAll("$DEPLOYED", getVersion(verExc.Deployed));
 458             xBox->set_primary_text(s);
 459             approve = xBox->run() == RET_OK;
 460             if (m_pDialogHelper)
 461                 m_pDialogHelper->decBusy();
 462             abort = !approve;
 463         }
 464     }
 465     else if (request >>= instExc)
 466     {
 467         if ( ! m_bWarnUser )
 468         {
 469             approve = true;
 470         }
 471         else
 472         {
 473             if ( m_pDialogHelper )
 474             {
 475                 SolarMutexGuard guard;
 476
 477                 approve = m_pDialogHelper->installExtensionWarn( instExc.displayName );
 478             }
 479             else
 480                 approve = false;
 481             abort = !approve;
 482         }
 483     }
 484     else if (request >>= platExc)
 485     {
 486         SolarMutexGuard guard;
 487         OUString sMsg(DpResId(RID_STR_UNSUPPORTED_PLATFORM));
 488         sMsg = sMsg.replaceAll("%Name", platExc.package->getDisplayName());
 489         if (m_pDialogHelper)
 490             m_pDialogHelper->incBusy();
 491         std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(activeDialog(),
 492                                                   VclMessageType::Warning, VclButtonsType::Ok, sMsg));
 493         xBox->run();
 494         if (m_pDialogHelper)
 495             m_pDialogHelper->decBusy();
 496         approve = true;
 497     }
 498
 499     if (!approve && !abort)
 500     {
 501         // forward to UUI handler:
 502         if (! m_xHandler.is()) {
 503             // late init:
 504             m_xHandler = task::InteractionHandler::createWithParentAndContext(m_xContext, nullptr, m_sTitle);
 505         }
 506         m_xHandler->handle( xRequest );
 507     }
 508     else
 509     {
 510         assert(approve != abort);
 511         // select:
 512         for (auto& cont : xRequest->getContinuations())
 513         {
 514             if (approve) {
 515                 uno::Reference<task::XInteractionApprove> xInteractionApprove(cont, uno::UNO_QUERY);
 516                 if (xInteractionApprove.is()) {
 517                     xInteractionApprove->select();
 518                     // don't query again for ongoing continuations:
 519                     break;
 520                 }
 521             }
 522             else /*if (abort)*/ {
 523                 uno::Reference<task::XInteractionAbort> xInteractionAbort(cont, uno::UNO_QUERY);
 524                 if (xInteractionAbort.is()) {
 525                     xInteractionAbort->select();
 526                     // don't query again for ongoing continuations:
 527                     break;
 528                 }
 529             }
 530         }
 531     }
 532 }
 533
 534
 535 // XProgressHandler
 536
 537 void ProgressCmdEnv::push( uno::Any const & rStatus )
 538 {
 539     update_( rStatus );
 540 }
 541
 542
 543 void ProgressCmdEnv::update_( uno::Any const & rStatus )
 544 {
 545     OUString text;
 546     if ( rStatus.hasValue() && !( rStatus >>= text) )
 547     {
 548         if ( auto e = o3tl::tryAccess<uno::Exception>(rStatus) )
 549             text = e->Message;
 550         if ( text.isEmpty() )
 551             text = ::comphelper::anyToString( rStatus ); // fallback
 552
 553         const SolarMutexGuard aGuard;
 554         if (m_pDialogHelper)
 555             m_pDialogHelper->incBusy();
 556         std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(activeDialog(),
 557                                                   VclMessageType::Warning, VclButtonsType::Ok, text));
 558         xBox->run();
 559         if (m_pDialogHelper)
 560             m_pDialogHelper->decBusy();
 561     }
 562     ++m_nCurrentProgress;
 563     updateProgress();
 564 }
 565
 566
 567 void ProgressCmdEnv::update( uno::Any const & rStatus )
 568 {
 569     update_( rStatus );
 570 }
 571
 572
 573 void ProgressCmdEnv::pop()
 574 {
 575     update_( uno::Any() ); // no message
 576 }
 577
 578
 579 ExtensionCmdQueue::Thread::Thread( DialogHelper *pDialogHelper,
 580                                    TheExtensionManager *pManager,
 581                                    uno::Reference< uno::XComponentContext > xContext ) :
 582     salhelper::Thread( "dp_gui_extensioncmdqueue" ),
 583     m_xContext(std::move( xContext )),
 584     m_pDialogHelper( pDialogHelper ),
 585     m_pManager( pManager ),
 586     m_sEnablingPackages( DpResId( RID_STR_ENABLING_PACKAGES ) ),
 587     m_sDisablingPackages( DpResId( RID_STR_DISABLING_PACKAGES ) ),
 588     m_sAddingPackages( DpResId( RID_STR_ADDING_PACKAGES ) ),
 589     m_sRemovingPackages( DpResId( RID_STR_REMOVING_PACKAGES ) ),
 590     m_sDefaultCmd( DpResId( RID_STR_ADD_PACKAGES ) ),
 591     m_sAcceptLicense( DpResId( RID_STR_ACCEPT_LICENSE ) ),
 592     m_eInput( NONE ),
 593     m_bStopped( false ),
 594     m_bWorking( false )
 595 {
 596     OSL_ASSERT( pDialogHelper );
 597 }
 598
 599
 600 void ExtensionCmdQueue::Thread::addExtension( const OUString &rExtensionURL,
 601                                               const OUString &rRepository,
 602                                               const bool bWarnUser )
 603 {
 604     if ( !rExtensionURL.isEmpty() )
 605     {
 606         TExtensionCmd pEntry = std::make_shared<ExtensionCmd>( ExtensionCmd::ADD, rExtensionURL, rRepository, bWarnUser );
 607         _insert( pEntry );
 608     }
 609 }
 610
 611
 612 void ExtensionCmdQueue::Thread::removeExtension( const uno::Reference< deployment::XPackage > &rPackage )
 613 {
 614     if ( rPackage.is() )
 615     {
 616         TExtensionCmd pEntry = std::make_shared<ExtensionCmd>( ExtensionCmd::REMOVE, rPackage );
 617         _insert( pEntry );
 618     }
 619 }
 620
 621
 622 void ExtensionCmdQueue::Thread::acceptLicense( const uno::Reference< deployment::XPackage > &rPackage )
 623 {
 624     if ( rPackage.is() )
 625     {
 626         TExtensionCmd pEntry = std::make_shared<ExtensionCmd>( ExtensionCmd::ACCEPT_LICENSE, rPackage );
 627         _insert( pEntry );
 628     }
 629 }
 630
 631
 632 void ExtensionCmdQueue::Thread::enableExtension( const uno::Reference< deployment::XPackage > &rPackage,
 633                                                  const bool bEnable )
 634 {
 635     if ( rPackage.is() )
 636     {
 637         TExtensionCmd pEntry = std::make_shared<ExtensionCmd>( bEnable ? ExtensionCmd::ENABLE :
 638                                                           ExtensionCmd::DISABLE,
 639                                                 rPackage );
 640         _insert( pEntry );
 641     }
 642 }
 643
 644
 645 void ExtensionCmdQueue::Thread::checkForUpdates(
 646     std::vector<uno::Reference<deployment::XPackage > > && vExtensionList )
 647 {
 648     TExtensionCmd pEntry = std::make_shared<ExtensionCmd>( ExtensionCmd::CHECK_FOR_UPDATES, std::move(vExtensionList) );
 649     _insert( pEntry );
 650 }
 651
 652
 653 //Stopping this thread will not abort the installation of extensions.
 654 void ExtensionCmdQueue::Thread::stop()
 655 {
 656     std::scoped_lock aGuard( m_mutex );
 657     m_bStopped = true;
 658     m_eInput = STOP;
 659     m_wakeup.notify_all();
 660 }
 661
 662
 663 bool ExtensionCmdQueue::Thread::isBusy()
 664 {
 665     std::scoped_lock aGuard( m_mutex );
 666     return m_bWorking;
 667 }
 668
 669
 670 ExtensionCmdQueue::Thread::~Thread() {}
 671
 672
 673 void ExtensionCmdQueue::Thread::execute()
 674 {
 675 #ifdef _WIN32
 676     //Needed for use of the service "com.sun.star.system.SystemShellExecute" in
 677     //DialogHelper::openWebBrowser
 678     int nNbCallCoInitializeExForReinit = 0;
 679     o3tl::safeCoInitializeEx(COINIT_APARTMENTTHREADED, nNbCallCoInitializeExForReinit);
 680 #endif
 681     for (;;)
 682     {
 683         int nSize;
 684         Input eInput;
 685         {
 686             std::unique_lock aGuard( m_mutex );
 687             while (m_eInput == NONE) {
 688                 m_wakeup.wait(aGuard);
 689             }
 690             eInput = m_eInput;
 691             m_eInput = NONE;
 692             nSize = m_queue.size();
 693             // coverity[missing_lock: FALSE] - maybe due to (by-design) unique_lock vs. scoped_lock?
 694             m_bWorking = false;
 695         }
 696
 697         if ( eInput == STOP )
 698             break;
 699
 700         // We only install the extension which are currently in the queue.
 701         // The progressbar will be set to show the progress of the current number
 702         // of extensions. If we allowed to add extensions now then the progressbar may
 703         // have reached the end while we still install newly added extensions.
 704         if ( nSize == 0 )
 705             continue;
 706
 707         ::rtl::Reference< ProgressCmdEnv > currentCmdEnv( new ProgressCmdEnv( m_xContext, m_pDialogHelper, m_sDefaultCmd ) );
 708
 709         // Do not lock the following part with addExtension. addExtension may be called in the main thread.
 710         // If the message box "Do you want to install the extension (or similar)" is shown and then
 711         // addExtension is called, which then blocks the main thread, then we deadlock.
 712         bool bStartProgress = true;
 713
 714         while ( --nSize >= 0 )
 715         {
 716             {
 717                 std::scoped_lock aGuard( m_mutex );
 718                 m_bWorking = true;
 719             }
 720
 721             try
 722             {
 723                 TExtensionCmd pEntry;
 724                 {
 725                     std::scoped_lock queueGuard( m_mutex );
 726                     pEntry = m_queue.front();
 727                     m_queue.pop();
 728                 }
 729
 730                 if ( bStartProgress && ( pEntry->m_eCmdType != ExtensionCmd::CHECK_FOR_UPDATES ) )
 731                 {
 732                     currentCmdEnv->startProgress();
 733                     bStartProgress = false;
 734                 }
 735
 736                 switch ( pEntry->m_eCmdType ) {
 737                 case ExtensionCmd::ADD :
 738                     _addExtension( currentCmdEnv, pEntry->m_sExtensionURL, pEntry->m_sRepository, pEntry->m_bWarnUser );
 739                     break;
 740                 case ExtensionCmd::REMOVE :
 741                     _removeExtension( currentCmdEnv, pEntry->m_xPackage );
 742                     break;
 743                 case ExtensionCmd::ENABLE :
 744                     _enableExtension( currentCmdEnv, pEntry->m_xPackage );
 745                     break;
 746                 case ExtensionCmd::DISABLE :
 747                     _disableExtension( currentCmdEnv, pEntry->m_xPackage );
 748                     break;
 749                 case ExtensionCmd::CHECK_FOR_UPDATES :
 750                     _checkForUpdates( std::vector(pEntry->m_vExtensionList) );
 751                     break;
 752                 case ExtensionCmd::ACCEPT_LICENSE :
 753                     _acceptLicense( currentCmdEnv, pEntry->m_xPackage );
 754                     break;
 755                 }
 756             }
 757             catch ( const ucb::CommandAbortedException & )
 758             {
 759                 //This exception is thrown when the user clicks cancel on the progressbar.
 760                 //Then we cancel the installation of all extensions and remove them from
 761                 //the queue.
 762                 {
 763                     std::scoped_lock queueGuard2(m_mutex);
 764                     while ( --nSize >= 0 )
 765                         m_queue.pop();
 766                 }
 767                 break;
 768             }
 769             catch ( const ucb::CommandFailedException & )
 770             {
 771                 //This exception is thrown when a user clicked cancel in the messagebox which was
 772                 //started by the interaction handler. For example the user will be asked if he/she
 773                 //really wants to install the extension.
 774                 //These interactions run for exactly one extension at a time. Therefore we continue
 775                 //with installing the remaining extensions.
 776                 continue;
 777             }
 778             catch ( const uno::Exception & )
 779             {
 780                 //Todo display the user an error
 781                 //see also DialogImpl::SyncPushButton::Click()
 782                 uno::Any exc( ::cppu::getCaughtException() );
 783                 OUString msg;
 784                 deployment::DeploymentException dpExc;
 785                 if (exc >>= dpExc)
 786                 {
 787                     if (auto e = o3tl::tryAccess<uno::Exception>(dpExc.Cause))
 788                     {
 789                         // notify error cause only:
 790                         msg = e->Message;
 791                     }
 792                 }
 793                 if (msg.isEmpty()) // fallback for debugging purposes
 794                     msg = ::comphelper::anyToString(exc);
 795
 796                 const SolarMutexGuard guard;
 797                 if (m_pDialogHelper)
 798                     m_pDialogHelper->incBusy();
 799
 800                 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(currentCmdEnv->activeDialog(),
 801                                                           VclMessageType::Warning, VclButtonsType::Ok, msg));
 802                 if (m_pDialogHelper)
 803                     xBox->set_title(m_pDialogHelper->getFrameWeld()->get_title());
 804                 xBox->run();
 805                 if (m_pDialogHelper)
 806                     m_pDialogHelper->decBusy();
 807                 //Continue with installation of the remaining extensions
 808             }
 809             {
 810                 std::scoped_lock aGuard( m_mutex );
 811                 m_bWorking = false;
 812             }
 813         }
 814
 815         {
 816             // when leaving the while loop with break, we should set working to false, too
 817             std::scoped_lock aGuard( m_mutex );
 818             m_bWorking = false;
 819         }
 820
 821         if ( !bStartProgress )
 822             currentCmdEnv->stopProgress();
 823     }
 824     //end for
 825 #ifdef _WIN32
 826     o3tl::safeCoUninitializeReinit(COINIT_MULTITHREADED, nNbCallCoInitializeExForReinit);
 827 #endif
 828 }
 829
 830
 831 void ExtensionCmdQueue::Thread::_addExtension( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
 832                                                const OUString &rPackageURL,
 833                                                const OUString &rRepository,
 834                                                const bool bWarnUser )
 835 {
 836     //check if we have a string in anyTitle. For example "unopkg gui \" caused anyTitle to be void
 837     //and anyTitle.get<OUString> throws as RuntimeException.
 838     uno::Any anyTitle;
 839     try
 840     {
 841         anyTitle = ::ucbhelper::Content( rPackageURL, rCmdEnv, m_xContext ).getPropertyValue( u"Title"_ustr );
 842     }
 843     catch ( const uno::Exception & )
 844     {
 845         return;
 846     }
 847
 848     OUString sName;
 849     if ( ! (anyTitle >>= sName) )
 850     {
 851         OSL_FAIL("Could not get file name for extension.");
 852         return;
 853     }
 854
 855     rCmdEnv->setWarnUser( bWarnUser );
 856     uno::Reference< deployment::XExtensionManager > xExtMgr = m_pManager->getExtensionManager();
 857     uno::Reference< task::XAbortChannel > xAbortChannel( xExtMgr->createAbortChannel() );
 858     OUString sTitle(
 859         m_sAddingPackages.replaceAll("%EXTENSION_NAME", sName));
 860     rCmdEnv->progressSection( sTitle, xAbortChannel );
 861
 862     try
 863     {
 864         xExtMgr->addExtension(rPackageURL, uno::Sequence<beans::NamedValue>(),
 865                               rRepository, xAbortChannel, rCmdEnv );
 866     }
 867     catch ( const ucb::CommandFailedException & )
 868     {
 869         // When the extension is already installed we'll get a dialog asking if we want to overwrite. If we then press
 870         // cancel this exception is thrown.
 871     }
 872     catch ( const ucb::CommandAbortedException & )
 873     {
 874         // User clicked the cancel button
 875         // TODO: handle cancel
 876     }
 877     rCmdEnv->setWarnUser( false );
 878 }
 879
 880
 881 void ExtensionCmdQueue::Thread::_removeExtension( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
 882                                                   const uno::Reference< deployment::XPackage > &xPackage )
 883 {
 884     uno::Reference< deployment::XExtensionManager > xExtMgr = m_pManager->getExtensionManager();
 885     uno::Reference< task::XAbortChannel > xAbortChannel( xExtMgr->createAbortChannel() );
 886     OUString sTitle(
 887         m_sRemovingPackages.replaceAll("%EXTENSION_NAME",
 888             xPackage->getDisplayName()));
 889     rCmdEnv->progressSection( sTitle, xAbortChannel );
 890
 891     OUString id( dp_misc::getIdentifier( xPackage ) );
 892     try
 893     {
 894         xExtMgr->removeExtension( id, xPackage->getName(), xPackage->getRepositoryName(), xAbortChannel, rCmdEnv );
 895     }
 896     catch ( const deployment::DeploymentException & )
 897     {}
 898     catch ( const ucb::CommandFailedException & )
 899     {}
 900     catch ( const ucb::CommandAbortedException & )
 901     {}
 902
 903     // Check, if there are still updates to be notified via menu bar icon
 904     uno::Sequence< uno::Sequence< OUString > > aItemList;
 905     UpdateDialog::createNotifyJob( false, aItemList );
 906 }
 907
 908
 909 void ExtensionCmdQueue::Thread::_checkForUpdates(
 910     std::vector<uno::Reference<deployment::XPackage > > && vExtensionList )
 911 {
 912     const SolarMutexGuard guard;
 913
 914     if (m_pDialogHelper)
 915         m_pDialogHelper->incBusy();
 916
 917     std::vector< UpdateData > vData;
 918     UpdateDialog aUpdateDialog(m_xContext, m_pDialogHelper ? m_pDialogHelper->getFrameWeld() : nullptr, std::move(vExtensionList), &vData);
 919
 920     aUpdateDialog.notifyMenubar( true, false ); // prepare the checking, if there updates to be notified via menu bar icon
 921
 922     bool bOk = aUpdateDialog.run() == RET_OK;
 923     if (m_pDialogHelper)
 924         m_pDialogHelper->decBusy();
 925
 926     if (bOk && !vData.empty())
 927     {
 928         // If there is at least one directly downloadable extension then we
 929         // open the install dialog.
 930         std::vector< UpdateData > dataDownload;
 931
 932         for (auto const& data : vData)
 933         {
 934             if ( data.sWebsiteURL.isEmpty() )
 935                 dataDownload.push_back(data);
 936         }
 937
 938         short nDialogResult = RET_OK;
 939         if ( !dataDownload.empty() )
 940         {
 941             if (m_pDialogHelper)
 942                 m_pDialogHelper->incBusy();
 943             UpdateInstallDialog aDlg(m_pDialogHelper ? m_pDialogHelper->getFrameWeld() : nullptr, dataDownload, m_xContext);
 944             nDialogResult = aDlg.run();
 945             if (m_pDialogHelper)
 946                 m_pDialogHelper->decBusy();
 947             aUpdateDialog.notifyMenubar( false, true ); // Check, if there are still pending updates to be notified via menu bar icon
 948         }
 949         else
 950             aUpdateDialog.notifyMenubar( false, false ); // Check, if there are pending updates to be notified via menu bar icon
 951
 952         //Now start the webbrowser and navigate to the websites where we get the updates
 953         if ( RET_OK == nDialogResult )
 954         {
 955             for (auto const& data : vData)
 956             {
 957                 if ( m_pDialogHelper && ( !data.sWebsiteURL.isEmpty() ) )
 958                     m_pDialogHelper->openWebBrowser( data.sWebsiteURL, m_pDialogHelper->getFrameWeld()->get_title() );
 959             }
 960         }
 961     }
 962     else
 963         aUpdateDialog.notifyMenubar( false, false ); // check if there updates to be notified via menu bar icon
 964 }
 965
 966
 967 void ExtensionCmdQueue::Thread::_enableExtension( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
 968                                                   const uno::Reference< deployment::XPackage > &xPackage )
 969 {
 970     if ( !xPackage.is() )
 971         return;
 972
 973     uno::Reference< deployment::XExtensionManager > xExtMgr = m_pManager->getExtensionManager();
 974     uno::Reference< task::XAbortChannel > xAbortChannel( xExtMgr->createAbortChannel() );
 975     OUString sTitle(
 976         m_sEnablingPackages.replaceAll("%EXTENSION_NAME",
 977             xPackage->getDisplayName()));
 978     rCmdEnv->progressSection( sTitle, xAbortChannel );
 979
 980     try
 981     {
 982         xExtMgr->enableExtension( xPackage, xAbortChannel, rCmdEnv );
 983         if ( m_pDialogHelper )
 984             m_pDialogHelper->updatePackageInfo( xPackage );
 985     }
 986     catch ( const ::ucb::CommandAbortedException & )
 987     {}
 988 }
 989
 990
 991 void ExtensionCmdQueue::Thread::_disableExtension( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
 992                                                    const uno::Reference< deployment::XPackage > &xPackage )
 993 {
 994     if ( !xPackage.is() )
 995         return;
 996
 997     uno::Reference< deployment::XExtensionManager > xExtMgr = m_pManager->getExtensionManager();
 998     uno::Reference< task::XAbortChannel > xAbortChannel( xExtMgr->createAbortChannel() );
 999     OUString sTitle(
1000         m_sDisablingPackages.replaceAll("%EXTENSION_NAME",
1001             xPackage->getDisplayName()));
1002     rCmdEnv->progressSection( sTitle, xAbortChannel );
1003
1004     try
1005     {
1006         xExtMgr->disableExtension( xPackage, xAbortChannel, rCmdEnv );
1007         if ( m_pDialogHelper )
1008             m_pDialogHelper->updatePackageInfo( xPackage );
1009     }
1010     catch ( const ::ucb::CommandAbortedException & )
1011     {}
1012 }
1013
1014
1015 void ExtensionCmdQueue::Thread::_acceptLicense( ::rtl::Reference< ProgressCmdEnv > const &rCmdEnv,
1016                                                 const uno::Reference< deployment::XPackage > &xPackage )
1017 {
1018     if ( !xPackage.is() )
1019         return;
1020
1021     uno::Reference< deployment::XExtensionManager > xExtMgr = m_pManager->getExtensionManager();
1022     uno::Reference< task::XAbortChannel > xAbortChannel( xExtMgr->createAbortChannel() );
1023     OUString sTitle(
1024         m_sAcceptLicense.replaceAll("%EXTENSION_NAME",
1025             xPackage->getDisplayName()));
1026     rCmdEnv->progressSection( sTitle, xAbortChannel );
1027
1028     try
1029     {
1030         xExtMgr->checkPrerequisitesAndEnable( xPackage, xAbortChannel, rCmdEnv );
1031         if ( m_pDialogHelper )
1032             m_pDialogHelper->updatePackageInfo( xPackage );
1033     }
1034     catch ( const ::ucb::CommandAbortedException & )
1035     {}
1036 }
1037
1038 void ExtensionCmdQueue::Thread::_insert(const TExtensionCmd& rExtCmd)
1039 {
1040     std::scoped_lock aGuard( m_mutex );
1041
1042     // If someone called stop then we do not process the command -> game over!
1043     if ( m_bStopped )
1044         return;
1045
1046     m_queue.push( rExtCmd );
1047     m_eInput = START;
1048     m_wakeup.notify_all();
1049 }
1050
1051
1052 ExtensionCmdQueue::ExtensionCmdQueue( DialogHelper * pDialogHelper,
1053                                       TheExtensionManager *pManager,
1054                                       const uno::Reference< uno::XComponentContext > &rContext )
1055   : m_thread( new Thread( pDialogHelper, pManager, rContext ) )
1056 {
1057     m_thread->launch();
1058 }
1059
1060 ExtensionCmdQueue::~ExtensionCmdQueue() {
1061     m_thread->stop();
1062     m_thread->join();
1063 }
1064
1065 void ExtensionCmdQueue::addExtension( const OUString & extensionURL,
1066                                       const OUString & repository,
1067                                       const bool bWarnUser )
1068 {
1069     m_thread->addExtension( extensionURL, repository, bWarnUser );
1070 }
1071
1072 void ExtensionCmdQueue::removeExtension( const uno::Reference< deployment::XPackage > &rPackage )
1073 {
1074     m_thread->removeExtension( rPackage );
1075 }
1076
1077 void ExtensionCmdQueue::enableExtension( const uno::Reference< deployment::XPackage > &rPackage,
1078                                          const bool bEnable )
1079 {
1080     m_thread->enableExtension( rPackage, bEnable );
1081 }
1082
1083 void ExtensionCmdQueue::checkForUpdates( std::vector<uno::Reference<deployment::XPackage > > && vExtensionList )
1084 {
1085     m_thread->checkForUpdates( std::move(vExtensionList) );
1086 }
1087
1088 void ExtensionCmdQueue::acceptLicense( const uno::Reference< deployment::XPackage > &rPackage )
1089 {
1090     m_thread->acceptLicense( rPackage );
1091 }
1092
1093 void ExtensionCmdQueue::syncRepositories( const uno::Reference< uno::XComponentContext > &xContext )
1094 {
1095     dp_misc::syncRepositories( false, new ProgressCmdEnv( xContext, nullptr, u"Extension Manager"_ustr ) );
1096 }
1097
1098 bool ExtensionCmdQueue::isBusy()
1099 {
1100     return m_thread->isBusy();
1101 }
1102
1103 void handleInteractionRequest( const uno::Reference< uno::XComponentContext > & xContext,
1104                                const uno::Reference< task::XInteractionRequest > & xRequest )
1105 {
1106     ::rtl::Reference< ProgressCmdEnv > xCmdEnv( new ProgressCmdEnv( xContext, nullptr, u"Extension Manager"_ustr ) );
1107     xCmdEnv->handle( xRequest );
1108 }
1109
1110 } //namespace dp_gui
1111
1112 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */