desktop/source/deployment/manager/dp_informationprovider.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  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_desktop.hxx"
  30
  31 #include <cppuhelper/implbase3.hxx>
  32
  33 #include "comphelper/servicedecl.hxx"
  34
  35 #include "com/sun/star/deployment/thePackageManagerFactory.hpp"
  36 #include "com/sun/star/deployment/UpdateInformationProvider.hpp"
  37 #include "com/sun/star/deployment/XPackage.hpp"
  38 #include "com/sun/star/deployment/XPackageInformationProvider.hpp"
  39 #include "com/sun/star/deployment/XPackageManager.hpp"
  40 #include "com/sun/star/deployment/XUpdateInformationProvider.hpp"
  41 #include "com/sun/star/lang/XServiceInfo.hpp"
  42 #include "com/sun/star/registry/XRegistryKey.hpp"
  43 #include "com/sun/star/task/XAbortChannel.hpp"
  44 #include "com/sun/star/ucb/CommandFailedException.hpp"
  45 #include "com/sun/star/ucb/XCommandEnvironment.hpp"
  46 #include "com/sun/star/uno/XComponentContext.hpp"
  47 #include "com/sun/star/xml/dom/XElement.hpp"
  48 #include "com/sun/star/xml/dom/XNode.hpp"
  49
  50 #include "com/sun/star/uno/Reference.hxx"
  51 #include "rtl/ustring.hxx"
  52 #include "ucbhelper/content.hxx"
  53
  54 #include "dp_dependencies.hxx"
  55 #include "dp_descriptioninfoset.hxx"
  56 #include "dp_identifier.hxx"
  57 #include "dp_version.hxx"
  58 #include "dp_misc.h"
  59
  60 namespace beans      = com::sun::star::beans ;
  61 namespace deployment = com::sun::star::deployment ;
  62 namespace lang       = com::sun::star::lang ;
  63 namespace registry   = com::sun::star::registry ;
  64 namespace task       = com::sun::star::task ;
  65 namespace css_ucb    = com::sun::star::ucb ;
  66 namespace uno        = com::sun::star::uno ;
  67 namespace xml = com::sun::star::xml ;
  68
  69 #define UNISTRING(s) rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(s))
  70
  71 namespace dp_info {
  72
  73 class PackageInformationProvider :
  74     public ::cppu::WeakImplHelper3< deployment::XPackageInformationProvider,
  75                                     css_ucb::XCommandEnvironment,
  76                                     task::XInteractionHandler >
  77 {
  78     public:
  79                  PackageInformationProvider( uno::Reference< uno::XComponentContext >const& xContext);
  80     virtual     ~PackageInformationProvider();
  81
  82     static uno::Sequence< rtl::OUString > getServiceNames();
  83     static rtl::OUString getImplName();
  84
  85     // XInteractionHandler
  86     virtual void SAL_CALL handle( const uno::Reference< task::XInteractionRequest >& Request )
  87                                 throw( uno::RuntimeException );
  88     // XCommandEnvironment
  89     virtual uno::Reference< task::XInteractionHandler > SAL_CALL getInteractionHandler()
  90         throw ( uno::RuntimeException ) { return static_cast<task::XInteractionHandler*>(this); };
  91
  92     virtual uno::Reference< css_ucb::XProgressHandler > SAL_CALL getProgressHandler()
  93         throw ( uno::RuntimeException ) { return uno::Reference< css_ucb::XProgressHandler >(); };
  94
  95     // XPackageInformationProvider
  96     virtual rtl::OUString SAL_CALL getPackageLocation( const rtl::OUString& extensionId )
  97         throw ( uno::RuntimeException );
  98     virtual uno::Sequence< uno::Sequence< rtl::OUString > > SAL_CALL isUpdateAvailable( const rtl::OUString& extensionId )
  99         throw ( uno::RuntimeException );
 100     virtual uno::Sequence< uno::Sequence< rtl::OUString > > SAL_CALL getExtensionList()
 101         throw ( uno::RuntimeException );
 102 //---------
 103 private:
 104
 105     uno::Reference< uno::XComponentContext> mxContext;
 106
 107     rtl::OUString getPackageLocation( const uno::Reference< deployment::XPackageManager > _xManager,
 108                                       const rtl::OUString& _sExtensionId );
 109
 110     uno::Reference< deployment::XUpdateInformationProvider > mxUpdateInformation;
 111
 112     uno::Sequence< uno::Reference< xml::dom::XElement > >
 113             getUpdateInformation( uno::Sequence< rtl::OUString > const & urls,
 114                                   rtl::OUString const & identifier ) const;
 115     uno::Sequence< uno::Reference< deployment::XPackage > >
 116             getPackages( const uno::Reference< deployment::XPackageManager > _xManager );
 117     uno::Sequence< uno::Sequence< rtl::OUString > > isUpdateAvailable( const uno::Reference< deployment::XPackageManager > _xManager,
 118                             const rtl::OUString& _sExtensionId );
 119     uno::Sequence< uno::Sequence< rtl::OUString > > getExtensionList( const uno::Reference< deployment::XPackageManager > _xManager );
 120     uno::Sequence< uno::Sequence< rtl::OUString > > concatLists( uno::Sequence< uno::Sequence< rtl::OUString > > aFirst,
 121                                                                  uno::Sequence< uno::Sequence< rtl::OUString > > aSecond );
 122 };
 123
 124 //------------------------------------------------------------------------------
 125
 126 PackageInformationProvider::PackageInformationProvider( uno::Reference< uno::XComponentContext > const& xContext) :
 127     mxContext( xContext ),
 128     mxUpdateInformation( deployment::UpdateInformationProvider::create( xContext ) )
 129 {
 130 }
 131
 132 //------------------------------------------------------------------------------
 133
 134 PackageInformationProvider::~PackageInformationProvider()
 135 {
 136 }
 137
 138 //------------------------------------------------------------------------------
 139 void SAL_CALL PackageInformationProvider::handle( uno::Reference< task::XInteractionRequest > const & rRequest)
 140     throw (uno::RuntimeException)
 141 {
 142     uno::Sequence< uno::Reference< task::XInteractionContinuation > > xContinuations = rRequest->getContinuations();
 143     if ( xContinuations.getLength() == 1 )
 144     {
 145         xContinuations[0]->select();
 146     }
 147 }
 148
 149 //------------------------------------------------------------------------------
 150 rtl::OUString PackageInformationProvider::getPackageLocation(
 151         const uno::Reference< deployment::XPackageManager > _xManager,
 152         const rtl::OUString& _rExtensionId )
 153 {
 154     rtl::OUString aLocationURL;
 155
 156     if ( _xManager.is() )
 157     {
 158         const uno::Sequence< uno::Reference< deployment::XPackage > > packages(
 159                 _xManager->getDeployedPackages(
 160                     uno::Reference< task::XAbortChannel >(),
 161                     static_cast < XCommandEnvironment *> (this) ) );
 162
 163         for ( int pos = packages.getLength(); pos--; )
 164         {
 165             try
 166             {
 167                 const rtl::OUString aName = packages[ pos ]->getName();
 168                 const beans::Optional< rtl::OUString > aID = packages[ pos ]->getIdentifier();
 169                 if ( aID.IsPresent && aID.Value.compareTo( _rExtensionId ) == 0 )
 170                 {
 171                     aLocationURL = packages[ pos ]->getURL();
 172                     break;
 173                 }
 174             }
 175             catch ( uno::RuntimeException & ) {}
 176         }
 177     }
 178
 179     return aLocationURL;
 180 }
 181
 182 //------------------------------------------------------------------------------
 183 //------------------------------------------------------------------------------
 184 //------------------------------------------------------------------------------
 185
 186 rtl::OUString SAL_CALL
 187 PackageInformationProvider::getPackageLocation( const rtl::OUString& _sExtensionId )
 188     throw ( uno::RuntimeException )
 189 {
 190     uno::Reference< deployment::XPackageManager > xManager;
 191     try {
 192         xManager = deployment::thePackageManagerFactory::get( mxContext )->getPackageManager( UNISTRING("user") );
 193     }
 194     catch ( css_ucb::CommandFailedException & ){}
 195     catch ( uno::RuntimeException & ) {}
 196
 197     rtl::OUString aLocationURL = getPackageLocation( xManager, _sExtensionId );
 198
 199     if ( aLocationURL.getLength() == 0 )
 200     {
 201         try {
 202             xManager = deployment::thePackageManagerFactory::get( mxContext )->getPackageManager( UNISTRING("shared") );
 203         }
 204         catch ( css_ucb::CommandFailedException & ){}
 205         catch ( uno::RuntimeException & ) {}
 206
 207         aLocationURL = getPackageLocation( xManager, _sExtensionId );
 208     }
 209
 210     if ( aLocationURL.getLength() )
 211     {
 212         ::ucbhelper::Content aContent( aLocationURL, NULL );
 213         aLocationURL = aContent.getURL();
 214     }
 215
 216     return aLocationURL;
 217 }
 218
 219 //------------------------------------------------------------------------------
 220
 221 uno::Sequence< uno::Sequence< rtl::OUString > > SAL_CALL
 222 PackageInformationProvider::isUpdateAvailable( const rtl::OUString& _sExtensionId )
 223     throw ( uno::RuntimeException )
 224 {
 225     uno::Sequence< uno::Sequence< rtl::OUString > > aUpdateListUser;
 226
 227     uno::Reference< deployment::XPackageManager > xManager;
 228     try {
 229         xManager = deployment::thePackageManagerFactory::get( mxContext )->getPackageManager( UNISTRING("user") );
 230     }
 231     catch ( css_ucb::CommandFailedException & ){}
 232     catch ( uno::RuntimeException & ) {}
 233
 234     aUpdateListUser = isUpdateAvailable( xManager, _sExtensionId );
 235
 236     uno::Sequence< uno::Sequence< rtl::OUString > > aUpdateListShared;
 237     try {
 238         xManager = deployment::thePackageManagerFactory::get( mxContext )->getPackageManager( UNISTRING("shared") );
 239     }
 240     catch ( css_ucb::CommandFailedException & ){}
 241     catch ( uno::RuntimeException & ) {}
 242
 243     aUpdateListShared = isUpdateAvailable( xManager, _sExtensionId );
 244
 245     if ( !aUpdateListUser.hasElements() )
 246         return aUpdateListShared;
 247     else if ( !aUpdateListShared.hasElements() )
 248         return aUpdateListUser;
 249     else
 250         return concatLists( aUpdateListUser, aUpdateListShared );
 251 }
 252
 253 //------------------------------------------------------------------------------
 254 uno::Sequence< uno::Sequence< rtl::OUString > > SAL_CALL PackageInformationProvider::getExtensionList()
 255     throw ( uno::RuntimeException )
 256 {
 257     uno::Sequence< uno::Sequence< rtl::OUString > > aListUser;
 258
 259     uno::Reference< deployment::XPackageManager > xManager;
 260     try {
 261         xManager = deployment::thePackageManagerFactory::get( mxContext )->getPackageManager( UNISTRING("user") );
 262     }
 263     catch ( css_ucb::CommandFailedException & ){}
 264     catch ( uno::RuntimeException & ) {}
 265
 266     aListUser = getExtensionList( xManager );
 267
 268     uno::Sequence< uno::Sequence< rtl::OUString > > aListShared;
 269     try {
 270         xManager = deployment::thePackageManagerFactory::get( mxContext )->getPackageManager( UNISTRING("shared") );
 271     }
 272     catch ( css_ucb::CommandFailedException & ){}
 273     catch ( uno::RuntimeException & ) {}
 274
 275     aListShared = getExtensionList( xManager );
 276
 277     if ( !aListUser.hasElements() )
 278         return aListShared;
 279     else if ( !aListShared.hasElements() )
 280         return aListUser;
 281     else
 282         return concatLists( aListUser, aListShared );
 283 }
 284
 285 //------------------------------------------------------------------------------
 286 //------------------------------------------------------------------------------
 287 //------------------------------------------------------------------------------
 288 uno::Sequence< uno::Reference< deployment::XPackage > >
 289     PackageInformationProvider::getPackages( const uno::Reference< deployment::XPackageManager > _xMgr )
 290 {
 291     uno::Sequence< uno::Reference< deployment::XPackage > > packages;
 292     try {
 293         packages = _xMgr->getDeployedPackages( uno::Reference< task::XAbortChannel >(),
 294                                                static_cast < XCommandEnvironment *> (this) );
 295     }
 296     catch ( deployment::DeploymentException & )
 297     {}
 298     catch ( css_ucb::CommandFailedException & )
 299     {}
 300     catch ( css_ucb::CommandAbortedException & )
 301     {}
 302     catch ( lang::IllegalArgumentException & e )
 303     {
 304         throw uno::RuntimeException(e.Message, e.Context);
 305     }
 306
 307     return packages;
 308 }
 309
 310 //------------------------------------------------------------------------------
 311 uno::Sequence< uno::Reference< xml::dom::XElement > >
 312     PackageInformationProvider::getUpdateInformation( uno::Sequence< rtl::OUString > const & urls,
 313                                                       rtl::OUString const & identifier ) const
 314 {
 315     try
 316     {
 317         return mxUpdateInformation->getUpdateInformation( urls, identifier );
 318     }
 319     catch ( uno::RuntimeException & ) {
 320         throw;
 321     }
 322     catch ( css_ucb::CommandFailedException & ) {}
 323     catch ( css_ucb::CommandAbortedException & ) {}
 324     catch ( uno::Exception & ) {}
 325
 326     return uno::Sequence< uno::Reference< xml::dom::XElement > >();
 327 }
 328
 329 //------------------------------------------------------------------------------
 330 uno::Sequence< uno::Sequence< rtl::OUString > >
 331     PackageInformationProvider::isUpdateAvailable(
 332                     const uno::Reference< deployment::XPackageManager > _xManager,
 333                     const rtl::OUString& _sExtensionId )
 334 {
 335     uno::Sequence< uno::Sequence< rtl::OUString > > aList;
 336     sal_Int32 nCount = 0;
 337     bool bPackageFound = false;
 338
 339     // If the package manager is readonly then the user cannot modify anything anyway
 340     // so we can abort the search here
 341     if ( _xManager.is() && ! _xManager->isReadOnly() )
 342     {
 343         uno::Sequence< uno::Reference< deployment::XPackage > > packages( getPackages( _xManager ) );
 344         uno::Sequence< uno::Reference< xml::dom::XElement > > defaultInfos;
 345
 346         for ( int pos = packages.getLength(); pos-- && !bPackageFound; )
 347         {
 348             uno::Reference< deployment::XPackage > package( packages[ pos ] );
 349             uno::Sequence< rtl::OUString > urls( package->getUpdateInformationURLs());
 350             uno::Sequence< uno::Reference< xml::dom::XElement > > infos;
 351             rtl::OUString id( dp_misc::getIdentifier( package ) );
 352
 353             if ( _sExtensionId.getLength() )
 354             {
 355                 if ( _sExtensionId == id )
 356                     bPackageFound = true;
 357                 else /* we have an ID and the IDs don't match, continue with next package */
 358                     continue;
 359             }
 360
 361             if ( urls.getLength() != 0)
 362             {
 363                 infos = getUpdateInformation( urls, id );
 364             }
 365             else
 366             {
 367                 if ( defaultInfos.getLength() == 0 )
 368                 {
 369                     const rtl::OUString defaultURL( dp_misc::getExtensionDefaultUpdateURL() );
 370                     if ( defaultURL.getLength() )
 371                         defaultInfos = getUpdateInformation( uno::Sequence< rtl::OUString >( &defaultURL, 1 ),
 372                                                              rtl::OUString() );
 373                 }
 374                 infos = defaultInfos;
 375             }
 376             rtl::OUString latestVersion( package->getVersion() );
 377             sal_Int32 latestIndex = -1;
 378             for ( sal_Int32 i = 0; i < infos.getLength(); ++i )
 379             {
 380                 dp_misc::DescriptionInfoset infoset( mxContext,
 381                                     uno::Reference< xml::dom::XNode >( infos[i], uno::UNO_QUERY_THROW));
 382                 boost::optional< rtl::OUString > id2( infoset.getIdentifier() );
 383
 384                 if (!id2)
 385                     continue;
 386
 387                 if (*id2 == id)
 388                 {
 389                     // check, if there are unsatisfied dependencies and ignore those updates
 390                     uno::Sequence< uno::Reference< xml::dom::XElement > > ds( dp_misc::Dependencies::check( infoset ) );
 391                     if ( ds.getLength() )
 392                         continue;
 393
 394                     rtl::OUString v( infoset.getVersion() );
 395                     if ( dp_misc::compareVersions( v, latestVersion ) == dp_misc::GREATER )
 396                     {
 397                         latestVersion = v;
 398                         latestIndex = i;
 399                     }
 400                 }
 401             }
 402             if ( latestIndex != -1 )
 403             {
 404                 rtl::OUString aNewEntry[2];
 405                 aNewEntry[0] = id;
 406                 aNewEntry[1] = latestVersion;
 407                 aList.realloc( ++nCount );
 408                 aList[ nCount-1 ] = ::uno::Sequence< rtl::OUString >( aNewEntry, 2 );
 409             }
 410         }
 411     }
 412     return aList;
 413 }
 414
 415 //------------------------------------------------------------------------------
 416 uno::Sequence< uno::Sequence< rtl::OUString > >
 417     PackageInformationProvider::getExtensionList(
 418                     const uno::Reference< deployment::XPackageManager > _xManager )
 419 {
 420     uno::Sequence< uno::Sequence< rtl::OUString > > aList;
 421
 422     if ( _xManager.is() )
 423     {
 424         uno::Sequence< uno::Reference< deployment::XPackage > > packages( getPackages( _xManager ) );
 425
 426         aList.realloc( packages.getLength() );
 427
 428         for ( int pos = packages.getLength(); pos--; )
 429         {
 430             uno::Reference< deployment::XPackage > package( packages[ pos ] );
 431             rtl::OUString aNewEntry[2];
 432
 433             aNewEntry[0] = dp_misc::getIdentifier( package );
 434             aNewEntry[1] = package->getVersion();
 435             aList[ pos ] = ::uno::Sequence< rtl::OUString >( aNewEntry, 2 );
 436         }
 437     }
 438     return aList;
 439 }
 440
 441 //------------------------------------------------------------------------------
 442 uno::Sequence< uno::Sequence< rtl::OUString > > PackageInformationProvider::concatLists(
 443             uno::Sequence< uno::Sequence< rtl::OUString > > aFirst,
 444             uno::Sequence< uno::Sequence< rtl::OUString > > aSecond )
 445 {
 446     sal_Int32 nFirstCount = aFirst.getLength();
 447     sal_Int32 nSecondCount = aSecond.getLength();
 448     sal_Int32 nIndex = nFirstCount;
 449
 450     for ( sal_Int32 i=0; i < nSecondCount; i++ )
 451     {
 452         bool bDuplicateEntry = false;
 453         for ( sal_Int32 j=0; j < nFirstCount; j++ )
 454         {
 455             if ( aFirst[ j ][0] == aSecond[ i ][0] )
 456             {
 457                 bDuplicateEntry = true;
 458                 break;
 459             }
 460         }
 461         if ( !bDuplicateEntry )
 462         {
 463             nIndex += 1;
 464             aFirst.realloc( nIndex );
 465             aFirst[ nIndex - 1 ] = aSecond[ i ];
 466         }
 467     }
 468     return aFirst;
 469 }
 470
 471 //------------------------------------------------------------------------------
 472 //------------------------------------------------------------------------------
 473 //------------------------------------------------------------------------------
 474
 475 namespace sdecl = comphelper::service_decl;
 476 sdecl::class_<PackageInformationProvider> servicePIP;
 477 extern sdecl::ServiceDecl const serviceDecl(
 478     servicePIP,
 479     // a private one:
 480     "com.sun.star.comp.deployment.PackageInformationProvider",
 481     "com.sun.star.comp.deployment.PackageInformationProvider" );
 482
 483 //------------------------------------------------------------------------------
 484 bool singleton_entries(
 485     uno::Reference< registry::XRegistryKey > const & xRegistryKey )
 486 {
 487     try {
 488         uno::Reference< registry::XRegistryKey > xKey(
 489             xRegistryKey->createKey(
 490                 serviceDecl.getImplementationName() +
 491                 // xxx todo: use future generated function to get singleton name
 492                 UNISTRING("/UNO/SINGLETONS/"
 493                       "com.sun.star.deployment.PackageInformationProvider") ) );
 494         xKey->setStringValue( serviceDecl.getSupportedServiceNames()[0] );
 495         return true;
 496     }
 497     catch (registry::InvalidRegistryException & exc) {
 498         (void) exc; // avoid warnings
 499         OSL_ENSURE( 0, ::rtl::OUStringToOString(
 500                         exc.Message, RTL_TEXTENCODING_UTF8 ).getStr() );
 501         return false;
 502     }
 503 }
 504
 505 } // namespace dp_info
 506
 507