extensions/source/update/check/updatecheckconfig.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_extensions.hxx"
  30
  31
  32 #include "updatecheckconfig.hxx"
  33 #include <com/sun/star/beans/PropertyValue.hpp>
  34 #include <com/sun/star/beans/XPropertyState.hpp>
  35
  36 #ifndef _COM_SUN_STAR_CONTAINER_CHANGESEVENT_HPP_
  37 #include <com/sun/star/beans/XPropertyState.hpp>
  38 #endif
  39
  40 #include <osl/security.hxx>
  41 #include <osl/time.h>
  42 #include <osl/file.hxx>
  43
  44 #ifdef WNT
  45 #ifdef _MSC_VER
  46 #pragma warning(push,1) // disable warnings within system headers
  47 #pragma warning(disable: 4917)
  48 #endif
  49 #include <shlobj.h>
  50 #ifdef _MSC_VER
  51 #pragma warning(pop)
  52 #endif
  53 #endif
  54
  55 namespace container = com::sun::star::container ;
  56 namespace beans = com::sun::star::beans ;
  57 namespace lang = com::sun::star::lang ;
  58 namespace util = com::sun::star::util ;
  59 namespace uno = com::sun::star::uno ;
  60
  61 #define UNISTRING(s) rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(s))
  62
  63 #define LAST_CHECK              "LastCheck"
  64 #define VERSION_FOUND           "UpdateVersionFound"
  65 #define UPDATE_VERSION          "UpdateVersion"
  66 #define UPDATE_BUILDID          "UpdateBuildId"
  67 #define UPDATE_DESCRIPTION      "UpdateDescription"
  68 #define DOWNLOAD_URL            "DownloadURL"
  69 #define IS_DIRECT_DOWNLOAD      "IsDirectDownload"
  70 #define OLD_VERSION             "UpdateFoundFor"
  71 #define AUTOCHECK_ENABLED       "AutoCheckEnabled"
  72 #define AUTODOWNLOAD_ENABLED    "AutoDownloadEnabled"
  73 #define CHECK_INTERVAL          "CheckInterval"
  74 #define LOCAL_FILE              "LocalFile"
  75 #define DOWNLOAD_SIZE           "DownloadSize"
  76 #define DOWNLOAD_PAUSED         "DownloadPaused"
  77 #define DOWNLOAD_DESTINATION    "DownloadDestination"
  78 #define RELEASE_NOTE            "ReleaseNote"
  79 #define EXTENSION_PREFIX        "Extension_"
  80
  81 static const sal_Char * const aUpdateEntryProperties[] = {
  82     UPDATE_VERSION,
  83     UPDATE_BUILDID,
  84     UPDATE_DESCRIPTION,
  85     DOWNLOAD_URL,
  86     IS_DIRECT_DOWNLOAD,
  87     RELEASE_NOTE"1",
  88     RELEASE_NOTE"2",
  89     RELEASE_NOTE"3",
  90     RELEASE_NOTE"4",
  91     RELEASE_NOTE"5",
  92     OLD_VERSION
  93 };
  94
  95 static const sal_uInt32 nUpdateEntryProperties = sizeof(aUpdateEntryProperties) / sizeof(sal_Char *);
  96
  97 //------------------------------------------------------------------------------
  98
  99 NamedValueByNameAccess::~NamedValueByNameAccess()
 100 {
 101 }
 102
 103 //------------------------------------------------------------------------------
 104
 105 ::com::sun::star::uno::Any
 106 NamedValueByNameAccess::getValue(const sal_Char * pName)
 107 {
 108     const sal_Int32 nLen = m_rValues.getLength();
 109     for( sal_Int32 n=0; n < nLen; ++n )
 110     {
 111         if( m_rValues[n].Name.equalsAscii( pName ) )
 112             return m_rValues[n].Value;
 113     }
 114     return ::com::sun::star::uno::Any();
 115 }
 116
 117
 118 //------------------------------------------------------------------------------
 119
 120 bool
 121 UpdateCheckROModel::isAutoCheckEnabled() const
 122 {
 123     return sal_True == m_aNameAccess.getValue(AUTOCHECK_ENABLED).get< sal_Bool >();
 124 }
 125
 126 //------------------------------------------------------------------------------
 127
 128 bool
 129 UpdateCheckROModel::isDownloadPaused() const
 130 {
 131     return sal_True == m_aNameAccess.getValue(DOWNLOAD_PAUSED).get< sal_Bool >();
 132 }
 133
 134 //------------------------------------------------------------------------------
 135
 136 rtl::OUString
 137 UpdateCheckROModel::getStringValue(const sal_Char * pStr) const
 138 {
 139     uno::Any aAny( m_aNameAccess.getValue(pStr) );
 140     rtl::OUString aRet;
 141
 142     aAny >>= aRet;
 143
 144     return aRet;
 145 }
 146
 147 //------------------------------------------------------------------------------
 148
 149 rtl::OUString UpdateCheckROModel::getLocalFileName() const
 150 {
 151     return getStringValue(LOCAL_FILE);
 152 };
 153
 154 //------------------------------------------------------------------------------
 155
 156 sal_Int64 UpdateCheckROModel::getDownloadSize() const
 157 {
 158     uno::Any aAny( m_aNameAccess.getValue(DOWNLOAD_SIZE) );
 159     sal_Int64 nRet = -1;
 160
 161     aAny >>= nRet;
 162     return nRet;
 163 };
 164
 165 //------------------------------------------------------------------------------
 166
 167 rtl::OUString
 168 UpdateCheckROModel::getUpdateEntryVersion() const
 169 {
 170     return getStringValue(OLD_VERSION);
 171 }
 172
 173 //------------------------------------------------------------------------------
 174
 175 void
 176 UpdateCheckROModel::getUpdateEntry(UpdateInfo& rInfo) const
 177 {
 178     rInfo.BuildId = getStringValue(UPDATE_BUILDID);
 179     rInfo.Version = getStringValue(UPDATE_VERSION);
 180     rInfo.Description = getStringValue(UPDATE_DESCRIPTION);
 181
 182     sal_Bool isDirectDownload = sal_False;
 183     m_aNameAccess.getValue(IS_DIRECT_DOWNLOAD) >>= isDirectDownload;
 184
 185     rInfo.Sources.push_back( DownloadSource( isDirectDownload, getStringValue(DOWNLOAD_URL) ) );
 186
 187     rtl::OString aStr(RELEASE_NOTE);
 188     for(sal_Int32 n=1; n < 6; ++n )
 189     {
 190         rtl::OUString aUStr = getStringValue(aStr + rtl::OString::valueOf(n));
 191         if( aUStr.getLength() > 0 )
 192             rInfo.ReleaseNotes.push_back(ReleaseNote((sal_Int8) n, aUStr));
 193     }
 194 }
 195
 196
 197 //------------------------------------------------------------------------------
 198
 199 rtl::OUString UpdateCheckConfig::getDesktopDirectory()
 200 {
 201     rtl::OUString aRet;
 202
 203 #ifdef WNT
 204     WCHAR szPath[MAX_PATH];
 205
 206     if( ! FAILED( SHGetSpecialFolderPathW( NULL, szPath, CSIDL_DESKTOPDIRECTORY, true ) ) )
 207     {
 208         aRet = rtl::OUString( reinterpret_cast< sal_Unicode * >(szPath) );
 209         osl::FileBase::getFileURLFromSystemPath( aRet, aRet );
 210     }
 211 #else
 212     // This should become a desktop specific setting in some system backend ..
 213     rtl::OUString aHomeDir;
 214     osl::Security().getHomeDir( aHomeDir );
 215     aRet = aHomeDir + rtl::OUString::createFromAscii("/Desktop");
 216
 217     // Set path to home directory when there is no /Desktop directory
 218     osl::Directory aDocumentsDir( aRet );
 219     if( osl::FileBase::E_None != aDocumentsDir.open() )
 220         aRet = aHomeDir;
 221 #endif
 222
 223     return aRet;
 224 }
 225
 226 //------------------------------------------------------------------------------
 227
 228 rtl::OUString UpdateCheckConfig::getAllUsersDirectory()
 229 {
 230     rtl::OUString aRet;
 231
 232 #ifdef WNT
 233     WCHAR szPath[MAX_PATH];
 234
 235     if( ! FAILED( SHGetSpecialFolderPathW( NULL, szPath, CSIDL_COMMON_DOCUMENTS, true ) ) )
 236     {
 237         aRet = rtl::OUString( reinterpret_cast< sal_Unicode * >(szPath) );
 238         osl::FileBase::RC rc;
 239         rc = osl::FileBase::getFileURLFromSystemPath( aRet, aRet );
 240     }
 241 #else
 242     osl::FileBase::getTempDirURL(aRet);
 243 #endif
 244
 245     return aRet;
 246 }
 247
 248 //------------------------------------------------------------------------------
 249
 250 UpdateCheckConfig::UpdateCheckConfig(
 251     const uno::Reference<container::XNameContainer>& xContainer,
 252     const ::rtl::Reference< UpdateCheckConfigListener >& rListener
 253 ) : m_xContainer(xContainer), m_rListener(rListener)
 254 {
 255 }
 256
 257 //------------------------------------------------------------------------------
 258
 259 UpdateCheckConfig::~UpdateCheckConfig()
 260 {
 261 }
 262
 263 //------------------------------------------------------------------------------
 264
 265 ::rtl::Reference< UpdateCheckConfig >
 266 UpdateCheckConfig::get(
 267     const uno::Reference<uno::XComponentContext>& xContext,
 268     const ::rtl::Reference< UpdateCheckConfigListener >& rListener)
 269 {
 270     if( !xContext.is() )
 271         throw uno::RuntimeException(
 272             UNISTRING( "UpdateCheckConfig: empty component context" ),
 273             uno::Reference< uno::XInterface >() );
 274
 275     uno::Reference< lang::XMultiComponentFactory > xServiceManager(xContext->getServiceManager());
 276
 277     if( !xServiceManager.is() )
 278         throw uno::RuntimeException(
 279             UNISTRING( "UpdateCheckConfig: unable to obtain service manager from component context" ),
 280             uno::Reference< uno::XInterface >() );
 281
 282     uno::Reference< lang::XMultiServiceFactory > xConfigProvider(
 283         xServiceManager->createInstanceWithContext( UNISTRING( "com.sun.star.configuration.ConfigurationProvider" ), xContext ),
 284         uno::UNO_QUERY_THROW);
 285
 286     beans::PropertyValue aProperty;
 287     aProperty.Name  = UNISTRING( "nodepath" );
 288     aProperty.Value = uno::makeAny( UNISTRING("org.openoffice.Office.Jobs/Jobs/UpdateCheck/Arguments") );
 289
 290     uno::Sequence< uno::Any > aArgumentList( 1 );
 291     aArgumentList[0] = uno::makeAny( aProperty );
 292
 293     uno::Reference< container::XNameContainer > xContainer(
 294         xConfigProvider->createInstanceWithArguments(
 295             UNISTRING("com.sun.star.configuration.ConfigurationUpdateAccess"), aArgumentList ),
 296         uno::UNO_QUERY_THROW );
 297
 298     return new UpdateCheckConfig( xContainer, rListener );
 299 }
 300
 301 //------------------------------------------------------------------------------
 302
 303 bool
 304 UpdateCheckConfig::isAutoCheckEnabled() const
 305 {
 306     sal_Bool nValue = sal_False;
 307     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( AUTOCHECK_ENABLED ) ) >>= nValue;
 308     return nValue;
 309 }
 310
 311 //------------------------------------------------------------------------------
 312
 313 bool
 314 UpdateCheckConfig::isAutoDownloadEnabled() const
 315 {
 316     sal_Bool nValue = sal_False;
 317     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( AUTODOWNLOAD_ENABLED ) ) >>= nValue;
 318     return nValue;
 319 }
 320
 321 //------------------------------------------------------------------------------
 322
 323 rtl::OUString
 324 UpdateCheckConfig::getUpdateEntryVersion() const
 325 {
 326     rtl::OUString aValue;
 327
 328     // getByName is defined as non const in XNameAccess
 329     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( OLD_VERSION ) ) >>= aValue;
 330
 331     return aValue;
 332 }
 333
 334 //------------------------------------------------------------------------------
 335
 336 sal_Int64
 337 UpdateCheckConfig::getLastChecked() const
 338 {
 339     sal_Int64 nValue = 0;
 340
 341     // getByName is defined as non const in XNameAccess
 342     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( LAST_CHECK ) ) >>= nValue;
 343
 344     return nValue;
 345 }
 346
 347 //------------------------------------------------------------------------------
 348
 349 sal_Int64
 350 UpdateCheckConfig::getCheckInterval() const
 351 {
 352     sal_Int64 nValue = 0;
 353
 354     // getByName is defined as non const in XNameAccess
 355     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( CHECK_INTERVAL ) ) >>= nValue;
 356
 357     return nValue;
 358 }
 359
 360 //------------------------------------------------------------------------------
 361
 362 rtl::OUString
 363 UpdateCheckConfig::getLocalFileName() const
 364 {
 365     rtl::OUString aName = UNISTRING(LOCAL_FILE);
 366     rtl::OUString aRet;
 367
 368     if( m_xContainer->hasByName(aName) )
 369         m_xContainer->getByName(aName) >>= aRet;
 370
 371     return aRet;
 372 }
 373
 374 //------------------------------------------------------------------------------
 375
 376 rtl::OUString
 377 UpdateCheckConfig::getDownloadDestination() const
 378 {
 379     rtl::OUString aName = UNISTRING(DOWNLOAD_DESTINATION);
 380     rtl::OUString aRet;
 381
 382     const_cast <UpdateCheckConfig *> (this)->getByName(aName) >>= aRet;
 383
 384     return aRet;
 385 }
 386
 387 //------------------------------------------------------------------------------
 388
 389 void
 390 UpdateCheckConfig::storeLocalFileName(const rtl::OUString& rLocalFileName, sal_Int64 nFileSize)
 391 {
 392     const sal_uInt8 nItems = 2;
 393     const rtl::OUString aNameList[nItems] = { UNISTRING(LOCAL_FILE), UNISTRING(DOWNLOAD_SIZE) };
 394     const uno::Any aValueList[nItems] = { uno::makeAny(rLocalFileName), uno::makeAny(nFileSize) };
 395
 396     for( sal_uInt8 i=0; i < nItems; ++i )
 397     {
 398         if( m_xContainer->hasByName(aNameList[i]) )
 399             m_xContainer->replaceByName(aNameList[i], aValueList[i]);
 400         else
 401             m_xContainer->insertByName(aNameList[i],aValueList[i]);
 402     }
 403
 404     commitChanges();
 405 }
 406
 407 //------------------------------------------------------------------------------
 408
 409 void
 410 UpdateCheckConfig::clearLocalFileName()
 411 {
 412     const sal_uInt8 nItems = 2;
 413     const rtl::OUString aNameList[nItems] = { UNISTRING(LOCAL_FILE), UNISTRING(DOWNLOAD_SIZE) };
 414
 415     for( sal_uInt8 i=0; i < nItems; ++i )
 416     {
 417         if( m_xContainer->hasByName(aNameList[i]) )
 418             m_xContainer->removeByName(aNameList[i]);
 419     }
 420
 421     commitChanges();
 422 }
 423
 424 //------------------------------------------------------------------------------
 425
 426 void
 427 UpdateCheckConfig::storeDownloadPaused(bool paused)
 428 {
 429     replaceByName(UNISTRING(DOWNLOAD_PAUSED) , uno::makeAny(paused));
 430     commitChanges();
 431 }
 432
 433 //------------------------------------------------------------------------------
 434
 435 void
 436 UpdateCheckConfig::updateLastChecked()
 437 {
 438     TimeValue systime;
 439     osl_getSystemTime(&systime);
 440
 441     sal_Int64 lastCheck = systime.Seconds;
 442
 443     replaceByName(UNISTRING(LAST_CHECK), uno::makeAny(lastCheck));
 444 }
 445
 446 //------------------------------------------------------------------------------
 447
 448 void
 449 UpdateCheckConfig::storeUpdateFound( const UpdateInfo& rInfo, const rtl::OUString& aCurrentBuild)
 450
 451 {
 452     bool autoDownloadEnabled = isAutoDownloadEnabled();
 453
 454     uno::Any aValues[nUpdateEntryProperties] =
 455     {
 456         uno::makeAny(rInfo.Version),
 457         uno::makeAny(rInfo.BuildId),
 458         uno::makeAny(rInfo.Description),
 459         uno::makeAny(rInfo.Sources[0].URL),
 460         uno::makeAny(rInfo.Sources[0].IsDirect ? sal_True : sal_False),
 461         uno::makeAny(getReleaseNote(rInfo, 1, autoDownloadEnabled) ),
 462         uno::makeAny(getReleaseNote(rInfo, 2, autoDownloadEnabled) ),
 463         uno::makeAny(getReleaseNote(rInfo, 3, autoDownloadEnabled) ),
 464         uno::makeAny(getReleaseNote(rInfo, 4, autoDownloadEnabled) ),
 465         uno::makeAny(getReleaseNote(rInfo, 5, autoDownloadEnabled) ),
 466         uno::makeAny(aCurrentBuild)
 467     };
 468
 469     rtl::OUString aName;
 470     for( sal_uInt32 n=0; n < nUpdateEntryProperties; ++n )
 471     {
 472         aName = rtl::OUString::createFromAscii(aUpdateEntryProperties[n]);
 473
 474         if( m_xContainer->hasByName(aName) )
 475             m_xContainer->replaceByName(aName, aValues[n]);
 476         else
 477             m_xContainer->insertByName(aName,aValues[n]);
 478     }
 479
 480     commitChanges();
 481 }
 482
 483 //------------------------------------------------------------------------------
 484
 485 void
 486 UpdateCheckConfig::clearUpdateFound()
 487 {
 488     rtl::OUString aName;
 489
 490     for( sal_uInt32 n=0; n < nUpdateEntryProperties; ++n )
 491     {
 492         aName = rtl::OUString::createFromAscii(aUpdateEntryProperties[n]);
 493
 494         try {
 495             if( m_xContainer->hasByName(aName) )
 496                 m_xContainer->removeByName(aName);
 497         } catch(const lang::WrappedTargetException& ) {
 498             // Can not remove value, probably in share layer
 499             OSL_ASSERT(false);
 500             m_xContainer->replaceByName(aName, uno::makeAny(rtl::OUString()));
 501         }
 502     }
 503
 504     /* As we have removed UpdateVersionFound from the shared configuration
 505      * existing entries in the user layer do not have a oor operation and
 506      * thus are completly ignored (which also means they can not be removed).
 507      */
 508
 509     commitChanges();
 510 }
 511
 512 //------------------------------------------------------------------------------
 513
 514 uno::Sequence< rtl::OUString >
 515 UpdateCheckConfig::getServiceNames()
 516 {
 517     uno::Sequence< rtl::OUString > aServiceList(1);
 518     aServiceList[0] = UNISTRING( "com.sun.star.setup.UpdateCheckConfig");
 519     return aServiceList;
 520 }
 521
 522 //------------------------------------------------------------------------------
 523
 524 rtl::OUString
 525 UpdateCheckConfig::getImplName()
 526 {
 527     return UNISTRING( "vnd.sun.UpdateCheckConfig");
 528 }
 529
 530 //------------------------------------------------------------------------------
 531
 532 uno::Type SAL_CALL
 533 UpdateCheckConfig::getElementType() throw (uno::RuntimeException)
 534 {
 535     return m_xContainer->getElementType();
 536 }
 537
 538 //------------------------------------------------------------------------------
 539
 540 sal_Bool SAL_CALL
 541 UpdateCheckConfig::hasElements() throw (uno::RuntimeException)
 542 {
 543     return m_xContainer->hasElements();
 544 }
 545
 546 //------------------------------------------------------------------------------
 547
 548 uno::Any SAL_CALL
 549 UpdateCheckConfig::getByName( const ::rtl::OUString& aName )
 550     throw (container::NoSuchElementException, lang::WrappedTargetException,  uno::RuntimeException)
 551 {
 552     uno::Any aValue = m_xContainer->getByName( aName );
 553
 554     // Provide dynamic default value
 555     if( aName.equalsAscii(DOWNLOAD_DESTINATION) )
 556     {
 557         rtl::OUString aStr;
 558         aValue >>= aStr;
 559
 560         if( aStr.getLength() == 0 )
 561             aValue = uno::makeAny(getDesktopDirectory());
 562     }
 563
 564     return aValue;
 565 }
 566
 567 //------------------------------------------------------------------------------
 568
 569 uno::Sequence< ::rtl::OUString > SAL_CALL
 570 UpdateCheckConfig::getElementNames(  ) throw (uno::RuntimeException)
 571 {
 572     return m_xContainer->getElementNames();
 573 }
 574
 575 //------------------------------------------------------------------------------
 576
 577 sal_Bool SAL_CALL
 578 UpdateCheckConfig::hasByName( const ::rtl::OUString& aName ) throw (uno::RuntimeException)
 579 {
 580     return m_xContainer->hasByName( aName );
 581 }
 582
 583 //------------------------------------------------------------------------------
 584
 585 void SAL_CALL
 586 UpdateCheckConfig::replaceByName( const ::rtl::OUString& aName, const uno::Any& aElement )
 587     throw (lang::IllegalArgumentException, container::NoSuchElementException,
 588            lang::WrappedTargetException, uno::RuntimeException)
 589 {
 590     return m_xContainer->replaceByName( aName, aElement );
 591 }
 592
 593 //------------------------------------------------------------------------------
 594 // XChangesBatch
 595
 596 void SAL_CALL
 597 UpdateCheckConfig::commitChanges()
 598     throw (lang::WrappedTargetException, uno::RuntimeException)
 599 {
 600     uno::Reference< util::XChangesBatch > xChangesBatch(m_xContainer, uno::UNO_QUERY);
 601     if( xChangesBatch.is() && xChangesBatch->hasPendingChanges() )
 602     {
 603         util::ChangesSet aChangesSet = xChangesBatch->getPendingChanges();
 604         xChangesBatch->commitChanges();
 605
 606         if( m_rListener.is() )
 607         {
 608             const sal_Int32 nChanges = aChangesSet.getLength();
 609             rtl::OUString aString;
 610
 611             for( sal_Int32 i=0; i<nChanges; ++i )
 612             {
 613                 aChangesSet[i].Accessor >>= aString;
 614
 615                 // FIXME: use non IgnoreAsciiCase version as soon as it becomes available
 616                 if( aString.endsWithIgnoreAsciiCaseAsciiL(AUTOCHECK_ENABLED "']", sizeof(AUTOCHECK_ENABLED)+1) )
 617                 {
 618                     sal_Bool bEnabled = sal_False;
 619                     aChangesSet[i].Element >>= bEnabled;
 620                     m_rListener->autoCheckStatusChanged(sal_True == bEnabled);
 621                 }
 622                 // FIXME: use non IgnoreAsciiCase version as soon as it becomes available
 623                 else if( aString.endsWithIgnoreAsciiCaseAsciiL(CHECK_INTERVAL "']", sizeof(CHECK_INTERVAL)+1) )
 624                 {
 625                     m_rListener->autoCheckIntervalChanged();
 626                 }
 627             }
 628         }
 629     }
 630 }
 631
 632 //------------------------------------------------------------------------------
 633
 634 sal_Bool SAL_CALL
 635 UpdateCheckConfig::hasPendingChanges(  ) throw (uno::RuntimeException)
 636 {
 637     uno::Reference< util::XChangesBatch > xChangesBatch(m_xContainer, uno::UNO_QUERY);
 638     if( xChangesBatch.is() )
 639         return xChangesBatch->hasPendingChanges();
 640
 641     return sal_False;
 642 }
 643
 644 //------------------------------------------------------------------------------
 645
 646 uno::Sequence< util::ElementChange > SAL_CALL
 647 UpdateCheckConfig::getPendingChanges(  ) throw (uno::RuntimeException)
 648 {
 649     uno::Reference< util::XChangesBatch > xChangesBatch(m_xContainer, uno::UNO_QUERY);
 650     if( xChangesBatch.is() )
 651         return xChangesBatch->getPendingChanges();
 652
 653     return uno::Sequence< util::ElementChange >();
 654 }
 655
 656 //------------------------------------------------------------------------------
 657 void UpdateCheckConfig::storeExtensionVersion( const rtl::OUString& rExtensionName,
 658                                                const rtl::OUString& rVersion )
 659 {
 660     const rtl::OUString aExtName = UNISTRING( EXTENSION_PREFIX ) + rExtensionName;
 661     const uno::Any aValue = uno::makeAny( rVersion );
 662
 663     if( m_xContainer->hasByName( aExtName ) )
 664         m_xContainer->replaceByName( aExtName, aValue );
 665     else
 666         m_xContainer->insertByName( aExtName, aValue );
 667
 668     commitChanges();
 669 }
 670
 671 //------------------------------------------------------------------------------
 672 bool UpdateCheckConfig::checkExtensionVersion( const rtl::OUString& rExtensionName,
 673                                                const rtl::OUString& rVersion )
 674 {
 675     const rtl::OUString aExtName = UNISTRING( EXTENSION_PREFIX ) + rExtensionName;
 676
 677     if( m_xContainer->hasByName( aExtName ) )
 678     {
 679         uno::Any aValue = m_xContainer->getByName( aExtName );
 680         rtl::OUString aStoredVersion;
 681         aValue >>= aStoredVersion;
 682
 683         if ( isVersionGreater( rVersion, aStoredVersion ) )
 684             return true;
 685         else
 686         {
 687             m_xContainer->removeByName( aExtName );
 688             commitChanges();
 689         }
 690     }
 691     return false;
 692 }
 693
 694 //------------------------------------------------------------------------------
 695 rtl::OUString UpdateCheckConfig::getSubVersion( const rtl::OUString& rVersion,
 696                                                 sal_Int32 *nIndex )
 697 {
 698     while ( *nIndex < rVersion.getLength() && rVersion[*nIndex] == '0')
 699     {
 700         ++*nIndex;
 701     }
 702
 703     return rVersion.getToken( 0, '.', *nIndex );
 704 }
 705
 706 //------------------------------------------------------------------------------
 707 // checks if the second version string is greater than the first one
 708
 709 bool UpdateCheckConfig::isVersionGreater( const rtl::OUString& rVersion1,
 710                                           const rtl::OUString& rVersion2 )
 711 {
 712     for ( sal_Int32 i1 = 0, i2 = 0; i1 >= 0 || i2 >= 0; )
 713     {
 714         ::rtl::OUString sSub1( getSubVersion( rVersion1, &i1 ) );
 715         ::rtl::OUString sSub2( getSubVersion( rVersion2, &i2 ) );
 716
 717         if ( sSub1.getLength() < sSub2.getLength() ) {
 718             return true;
 719         } else if ( sSub1.getLength() > sSub2.getLength() ) {
 720             return false;
 721         } else if ( sSub1 < sSub2 ) {
 722             return true;
 723         } else if ( sSub1 > sSub2 ) {
 724             return false;
 725         }
 726     }
 727     return false;
 728 }
 729
 730 //------------------------------------------------------------------------------
 731 //------------------------------------------------------------------------------
 732 //------------------------------------------------------------------------------
 733
 734 rtl::OUString SAL_CALL
 735 UpdateCheckConfig::getImplementationName()  throw (uno::RuntimeException)
 736 {
 737     return getImplName();
 738 }
 739
 740 //------------------------------------------------------------------------------
 741
 742 sal_Bool SAL_CALL
 743 UpdateCheckConfig::supportsService(rtl::OUString const & serviceName)
 744     throw (uno::RuntimeException)
 745 {
 746     uno::Sequence< rtl::OUString > aServiceNameList = getServiceNames();
 747
 748     for( sal_Int32 n=0; n < aServiceNameList.getLength(); n++ )
 749         if( aServiceNameList[n].equals(serviceName) )
 750             return sal_True;
 751
 752     return sal_False;
 753 }
 754
 755 //------------------------------------------------------------------------------
 756
 757 uno::Sequence< rtl::OUString > SAL_CALL
 758 UpdateCheckConfig::getSupportedServiceNames()  throw (uno::RuntimeException)
 759 {
 760     return getServiceNames();
 761 }
 762
 763