desktop/source/deployment/manager/dp_commandenvironments.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
  21 #include "com/sun/star/deployment/VersionException.hpp"
  22 #include "com/sun/star/deployment/LicenseException.hpp"
  23 #include "com/sun/star/deployment/InstallException.hpp"
  24 #include "com/sun/star/deployment/DependencyException.hpp"
  25 #include "com/sun/star/deployment/PlatformException.hpp"
  26 #include "com/sun/star/task/XInteractionApprove.hpp"
  27 #include "com/sun/star/task/XInteractionAbort.hpp"
  28 #include "com/sun/star/task/XInteractionHandler.hpp"
  29 #include "com/sun/star/ucb/XCommandEnvironment.hpp"
  30 #include "com/sun/star/uno/XComponentContext.hpp"
  31 #include "dp_commandenvironments.hxx"
  32
  33 namespace deployment = com::sun::star::deployment;
  34 namespace task = com::sun::star::task;
  35 namespace ucb = com::sun::star::ucb;
  36 namespace uno = com::sun::star::uno;
  37
  38 using ::com::sun::star::uno::Reference;
  39
  40 namespace dp_manager {
  41
  42 BaseCommandEnv::BaseCommandEnv()
  43 {
  44 }
  45
  46 BaseCommandEnv::BaseCommandEnv(
  47     Reference< task::XInteractionHandler> const & handler)
  48     : m_forwardHandler(handler)
  49 {
  50 }
  51
  52 BaseCommandEnv::~BaseCommandEnv()
  53 {
  54 }
  55 // XCommandEnvironment
  56 //______________________________________________________________________________
  57 Reference<task::XInteractionHandler> BaseCommandEnv::getInteractionHandler()
  58 throw (uno::RuntimeException)
  59 {
  60     return this;
  61 }
  62
  63 //______________________________________________________________________________
  64 Reference<ucb::XProgressHandler> BaseCommandEnv::getProgressHandler()
  65 throw (uno::RuntimeException)
  66 {
  67     return this;
  68 }
  69
  70 void BaseCommandEnv::handle(
  71     Reference< task::XInteractionRequest> const & /*xRequest*/ )
  72     throw (uno::RuntimeException)
  73 {
  74 }
  75
  76 void BaseCommandEnv::handle_(bool approve, bool abort,
  77                              Reference< task::XInteractionRequest> const & xRequest )
  78 {
  79     if (approve == false && abort == false)
  80     {
  81         //not handled so far -> forwarding
  82         if (m_forwardHandler.is())
  83             m_forwardHandler->handle(xRequest);
  84         else
  85             return; //cannot handle
  86     }
  87     else
  88     {
  89         // select:
  90         uno::Sequence< Reference< task::XInteractionContinuation > > conts(
  91             xRequest->getContinuations() );
  92         Reference< task::XInteractionContinuation > const * pConts =
  93             conts.getConstArray();
  94         sal_Int32 len = conts.getLength();
  95         for ( sal_Int32 pos = 0; pos < len; ++pos )
  96         {
  97             if (approve) {
  98                 Reference< task::XInteractionApprove > xInteractionApprove(
  99                     pConts[ pos ], uno::UNO_QUERY );
 100                 if (xInteractionApprove.is()) {
 101                     xInteractionApprove->select();
 102                     // don't query again for ongoing continuations:
 103                     approve = false;
 104                 }
 105             }
 106             else if (abort) {
 107                 Reference< task::XInteractionAbort > xInteractionAbort(
 108                     pConts[ pos ], uno::UNO_QUERY );
 109                 if (xInteractionAbort.is()) {
 110                     xInteractionAbort->select();
 111                     // don't query again for ongoing continuations:
 112                     abort = false;
 113                 }
 114             }
 115         }
 116     }
 117
 118 }
 119
 120 // XProgressHandler
 121 void BaseCommandEnv::push( uno::Any const & /*Status*/ )
 122 throw (uno::RuntimeException)
 123 {
 124 }
 125
 126 void BaseCommandEnv::update( uno::Any const & /*Status */)
 127 throw (uno::RuntimeException)
 128 {
 129 }
 130
 131 void BaseCommandEnv::pop() throw (uno::RuntimeException)
 132 {
 133 }
 134 //==============================================================================
 135
 136 TmpRepositoryCommandEnv::TmpRepositoryCommandEnv()
 137 {
 138 }
 139
 140 TmpRepositoryCommandEnv::TmpRepositoryCommandEnv(
 141     css::uno::Reference< css::task::XInteractionHandler> const & handler):
 142     BaseCommandEnv(handler)
 143 {
 144 }
 145 // XInteractionHandler
 146 void TmpRepositoryCommandEnv::handle(
 147     Reference< task::XInteractionRequest> const & xRequest )
 148     throw (uno::RuntimeException)
 149 {
 150     uno::Any request( xRequest->getRequest() );
 151     OSL_ASSERT( request.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 152
 153     deployment::VersionException verExc;
 154     deployment::LicenseException licExc;
 155     deployment::InstallException instExc;
 156
 157     bool approve = false;
 158     bool abort = false;
 159
 160     if ((request >>= verExc)
 161         || (request >>= licExc)
 162         || (request >>= instExc))
 163     {
 164         approve = true;
 165     }
 166
 167     handle_(approve, abort, xRequest);
 168 }
 169 //================================================================================
 170
 171 LicenseCommandEnv::LicenseCommandEnv(
 172     css::uno::Reference< css::task::XInteractionHandler> const & handler,
 173     bool bSuppressLicense,
 174     OUString const & repository):
 175     BaseCommandEnv(handler), m_repository(repository),
 176     m_bSuppressLicense(bSuppressLicense)
 177 {
 178 }
 179 // XInteractionHandler
 180 void LicenseCommandEnv::handle(
 181     Reference< task::XInteractionRequest> const & xRequest )
 182     throw (uno::RuntimeException)
 183 {
 184     uno::Any request( xRequest->getRequest() );
 185     OSL_ASSERT( request.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 186
 187     deployment::LicenseException licExc;
 188
 189     bool approve = false;
 190     bool abort = false;
 191
 192     if (request >>= licExc)
 193     {
 194         if (m_bSuppressLicense
 195             || m_repository == "bundled"
 196             || licExc.AcceptBy == "admin")
 197         {
 198             //always approve in bundled case, because we do not support
 199             //showing licenses anyway.
 200             //The "admin" already accepted the license when installing the
 201             // shared extension
 202             approve = true;
 203         }
 204     }
 205
 206     handle_(approve, abort, xRequest);
 207 }
 208
 209 //================================================================================
 210
 211 NoLicenseCommandEnv::NoLicenseCommandEnv(
 212     css::uno::Reference< css::task::XInteractionHandler> const & handler):
 213     BaseCommandEnv(handler)
 214 {
 215 }
 216 // XInteractionHandler
 217 void NoLicenseCommandEnv::handle(
 218     Reference< task::XInteractionRequest> const & xRequest )
 219     throw (uno::RuntimeException)
 220 {
 221     uno::Any request( xRequest->getRequest() );
 222     OSL_ASSERT( request.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 223
 224     deployment::LicenseException licExc;
 225
 226     bool approve = false;
 227     bool abort = false;
 228
 229     if (request >>= licExc)
 230     {
 231         approve = true;
 232     }
 233     handle_(approve, abort, xRequest);
 234 }
 235
 236 SilentCheckPrerequisitesCommandEnv::SilentCheckPrerequisitesCommandEnv()
 237 {
 238 }
 239
 240 void SilentCheckPrerequisitesCommandEnv::handle(
 241        Reference< task::XInteractionRequest> const & xRequest )
 242     throw (uno::RuntimeException)
 243 {
 244     uno::Any request( xRequest->getRequest() );
 245     OSL_ASSERT( request.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 246
 247     deployment::LicenseException licExc;
 248     deployment::PlatformException platformExc;
 249     deployment::DependencyException depExc;
 250
 251     if (request >>= licExc)
 252     {
 253         handle_(true, false, xRequest); // approve = true, abort = false
 254     }
 255     else if ((request >>= platformExc)
 256              || (request >>= depExc))
 257     {
 258         m_Exception = request;
 259     }
 260     else
 261     {
 262         m_UnknownException = request;
 263     }
 264 }
 265
 266 }
 267
 268 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */