extensions/source/update/check/updatecheckconfig.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30
  31 #include "updatecheckconfig.hxx"
  32 #include <com/sun/star/beans/PropertyValue.hpp>
  33 #include <com/sun/star/beans/XPropertyState.hpp>
  34 #include <com/sun/star/beans/XPropertySet.hpp>
  35 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  36 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  37 #include <osl/security.hxx>
  38 #include <osl/time.h>
  39 #include <osl/file.hxx>
  40 #include <sal/macros.h>
  41
  42 #ifdef WNT
  43 #ifdef _MSC_VER
  44 #pragma warning(push,1) // disable warnings within system headers
  45 #pragma warning(disable: 4917)
  46 #endif
  47 #include <shlobj.h>
  48 #ifdef _MSC_VER
  49 #pragma warning(pop)
  50 #endif
  51 #endif
  52
  53 namespace container = com::sun::star::container ;
  54 namespace beans = com::sun::star::beans ;
  55 namespace lang = com::sun::star::lang ;
  56 namespace util = com::sun::star::util ;
  57 namespace uno = com::sun::star::uno ;
  58
  59 #define UNISTRING(s) rtl::OUString(s)
  60
  61 #define LAST_CHECK              "LastCheck"
  62 #define VERSION_FOUND           "UpdateVersionFound"
  63 #define UPDATE_VERSION          "UpdateVersion"
  64 #define UPDATE_BUILDID          "UpdateBuildId"
  65 #define UPDATE_DESCRIPTION      "UpdateDescription"
  66 #define DOWNLOAD_URL            "DownloadURL"
  67 #define IS_DIRECT_DOWNLOAD      "IsDirectDownload"
  68 #define OLD_VERSION             "UpdateFoundFor"
  69 #define AUTOCHECK_ENABLED       "AutoCheckEnabled"
  70 #define AUTODOWNLOAD_ENABLED    "AutoDownloadEnabled"
  71 #define CHECK_INTERVAL          "CheckInterval"
  72 #define LOCAL_FILE              "LocalFile"
  73 #define DOWNLOAD_SIZE           "DownloadSize"
  74 #define DOWNLOAD_PAUSED         "DownloadPaused"
  75 #define DOWNLOAD_DESTINATION    "DownloadDestination"
  76 #define RELEASE_NOTE            "ReleaseNote"
  77 #define EXTENSION_PREFIX        "Extension_"
  78
  79 #define PROPERTY_VERSION        UNISTRING("Version")
  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 = SAL_N_ELEMENTS(aUpdateEntryProperties);
  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(
 191             (aStr + rtl::OString::valueOf(n)).getStr());
 192         if( !aUStr.isEmpty() )
 193             rInfo.ReleaseNotes.push_back(ReleaseNote((sal_Int8) n, aUStr));
 194     }
 195 }
 196
 197
 198 //------------------------------------------------------------------------------
 199
 200 rtl::OUString UpdateCheckConfig::getDesktopDirectory()
 201 {
 202     rtl::OUString aRet;
 203
 204 #ifdef WNT
 205     WCHAR szPath[MAX_PATH];
 206
 207     if( ! FAILED( SHGetSpecialFolderPathW( NULL, szPath, CSIDL_DESKTOPDIRECTORY, true ) ) )
 208     {
 209         aRet = rtl::OUString( reinterpret_cast< sal_Unicode * >(szPath) );
 210         osl::FileBase::getFileURLFromSystemPath( aRet, aRet );
 211     }
 212 #else
 213     // This should become a desktop specific setting in some system backend ..
 214     rtl::OUString aHomeDir;
 215     osl::Security().getHomeDir( aHomeDir );
 216     aRet = aHomeDir + rtl::OUString("/Desktop");
 217
 218     // Set path to home directory when there is no /Desktop directory
 219     osl::Directory aDocumentsDir( aRet );
 220     if( osl::FileBase::E_None != aDocumentsDir.open() )
 221         aRet = aHomeDir;
 222 #endif
 223
 224     return aRet;
 225 }
 226
 227 //------------------------------------------------------------------------------
 228
 229 rtl::OUString UpdateCheckConfig::getAllUsersDirectory()
 230 {
 231     rtl::OUString aRet;
 232
 233 #ifdef WNT
 234     WCHAR szPath[MAX_PATH];
 235
 236     if( ! FAILED( SHGetSpecialFolderPathW( NULL, szPath, CSIDL_COMMON_DOCUMENTS, true ) ) )
 237     {
 238         aRet = rtl::OUString( reinterpret_cast< sal_Unicode * >(szPath) );
 239         osl::FileBase::getFileURLFromSystemPath( aRet, aRet );
 240     }
 241 #else
 242     osl::FileBase::getTempDirURL(aRet);
 243 #endif
 244
 245     return aRet;
 246 }
 247
 248 //------------------------------------------------------------------------------
 249 UpdateCheckConfig::UpdateCheckConfig( const uno::Reference<container::XNameContainer>& xContainer,
 250                                       const uno::Reference<container::XNameContainer>& xAvailableUpdates,
 251                                       const uno::Reference<container::XNameContainer>& xIgnoredUpdates,
 252                                       const ::rtl::Reference< UpdateCheckConfigListener >& rListener ) :
 253     m_xContainer( xContainer ),
 254     m_xAvailableUpdates( xAvailableUpdates ),
 255     m_xIgnoredUpdates( xIgnoredUpdates ),
 256     m_rListener( rListener )
 257 {}
 258
 259 //------------------------------------------------------------------------------
 260 UpdateCheckConfig::~UpdateCheckConfig()
 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     uno::Reference< lang::XMultiServiceFactory > xConfigProvider(
 271         com::sun::star::configuration::theDefaultProvider::get( xContext ) );
 272
 273     beans::PropertyValue aProperty;
 274     aProperty.Name  = UNISTRING( "nodepath" );
 275     aProperty.Value = uno::makeAny( UNISTRING("org.openoffice.Office.Jobs/Jobs/UpdateCheck/Arguments") );
 276
 277     uno::Sequence< uno::Any > aArgumentList( 1 );
 278     aArgumentList[0] = uno::makeAny( aProperty );
 279
 280     uno::Reference< container::XNameContainer > xContainer(
 281         xConfigProvider->createInstanceWithArguments(
 282             UNISTRING("com.sun.star.configuration.ConfigurationUpdateAccess"), aArgumentList ),
 283         uno::UNO_QUERY_THROW );
 284
 285     aProperty.Value = uno::makeAny( UNISTRING("/org.openoffice.Office.ExtensionManager/ExtensionUpdateData/IgnoredUpdates") );
 286     aArgumentList[0] = uno::makeAny( aProperty );
 287     uno::Reference< container::XNameContainer > xIgnoredExt( xConfigProvider->createInstanceWithArguments( UNISTRING("com.sun.star.configuration.ConfigurationUpdateAccess"), aArgumentList ), uno::UNO_QUERY_THROW );
 288
 289     aProperty.Value = uno::makeAny( UNISTRING("/org.openoffice.Office.ExtensionManager/ExtensionUpdateData/AvailableUpdates") );
 290     aArgumentList[0] = uno::makeAny( aProperty );
 291     uno::Reference< container::XNameContainer > xUpdateAvail( xConfigProvider->createInstanceWithArguments( UNISTRING("com.sun.star.configuration.ConfigurationUpdateAccess"), aArgumentList ), uno::UNO_QUERY_THROW );
 292
 293     return new UpdateCheckConfig( xContainer, xUpdateAvail, xIgnoredExt, rListener );
 294 }
 295
 296 //------------------------------------------------------------------------------
 297
 298 bool
 299 UpdateCheckConfig::isAutoCheckEnabled() const
 300 {
 301     sal_Bool nValue = sal_False;
 302     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( AUTOCHECK_ENABLED ) ) >>= nValue;
 303     return nValue;
 304 }
 305
 306 //------------------------------------------------------------------------------
 307
 308 bool
 309 UpdateCheckConfig::isAutoDownloadEnabled() const
 310 {
 311     sal_Bool nValue = sal_False;
 312     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( AUTODOWNLOAD_ENABLED ) ) >>= nValue;
 313     return nValue;
 314 }
 315
 316 //------------------------------------------------------------------------------
 317
 318 rtl::OUString
 319 UpdateCheckConfig::getUpdateEntryVersion() const
 320 {
 321     rtl::OUString aValue;
 322
 323     // getByName is defined as non const in XNameAccess
 324     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( OLD_VERSION ) ) >>= aValue;
 325
 326     return aValue;
 327 }
 328
 329 //------------------------------------------------------------------------------
 330
 331 sal_Int64
 332 UpdateCheckConfig::getLastChecked() const
 333 {
 334     sal_Int64 nValue = 0;
 335
 336     // getByName is defined as non const in XNameAccess
 337     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( LAST_CHECK ) ) >>= nValue;
 338
 339     return nValue;
 340 }
 341
 342 //------------------------------------------------------------------------------
 343
 344 sal_Int64
 345 UpdateCheckConfig::getCheckInterval() const
 346 {
 347     sal_Int64 nValue = 0;
 348
 349     // getByName is defined as non const in XNameAccess
 350     const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( CHECK_INTERVAL ) ) >>= nValue;
 351
 352     return nValue;
 353 }
 354
 355 //------------------------------------------------------------------------------
 356
 357 rtl::OUString
 358 UpdateCheckConfig::getLocalFileName() const
 359 {
 360     rtl::OUString aName = UNISTRING(LOCAL_FILE);
 361     rtl::OUString aRet;
 362
 363     if( m_xContainer->hasByName(aName) )
 364         m_xContainer->getByName(aName) >>= aRet;
 365
 366     return aRet;
 367 }
 368
 369 //------------------------------------------------------------------------------
 370
 371 rtl::OUString
 372 UpdateCheckConfig::getDownloadDestination() const
 373 {
 374     rtl::OUString aName = UNISTRING(DOWNLOAD_DESTINATION);
 375     rtl::OUString aRet;
 376
 377     const_cast <UpdateCheckConfig *> (this)->getByName(aName) >>= aRet;
 378
 379     return aRet;
 380 }
 381
 382 //------------------------------------------------------------------------------
 383
 384 void
 385 UpdateCheckConfig::storeLocalFileName(const rtl::OUString& rLocalFileName, sal_Int64 nFileSize)
 386 {
 387     const sal_uInt8 nItems = 2;
 388     const rtl::OUString aNameList[nItems] = { UNISTRING(LOCAL_FILE), UNISTRING(DOWNLOAD_SIZE) };
 389     const uno::Any aValueList[nItems] = { uno::makeAny(rLocalFileName), uno::makeAny(nFileSize) };
 390
 391     for( sal_uInt8 i=0; i < nItems; ++i )
 392     {
 393         if( m_xContainer->hasByName(aNameList[i]) )
 394             m_xContainer->replaceByName(aNameList[i], aValueList[i]);
 395         else
 396             m_xContainer->insertByName(aNameList[i], aValueList[i]);
 397     }
 398
 399     commitChanges();
 400 }
 401
 402 //------------------------------------------------------------------------------
 403
 404 void
 405 UpdateCheckConfig::clearLocalFileName()
 406 {
 407     const sal_uInt8 nItems = 2;
 408     const rtl::OUString aNameList[nItems] = { UNISTRING(LOCAL_FILE), UNISTRING(DOWNLOAD_SIZE) };
 409
 410     for( sal_uInt8 i=0; i < nItems; ++i )
 411     {
 412         if( m_xContainer->hasByName(aNameList[i]) )
 413             m_xContainer->removeByName(aNameList[i]);
 414     }
 415
 416     commitChanges();
 417 }
 418
 419 //------------------------------------------------------------------------------
 420
 421 void
 422 UpdateCheckConfig::storeDownloadPaused(bool paused)
 423 {
 424     replaceByName(UNISTRING(DOWNLOAD_PAUSED) , uno::makeAny(paused));
 425     commitChanges();
 426 }
 427
 428 //------------------------------------------------------------------------------
 429
 430 void
 431 UpdateCheckConfig::updateLastChecked()
 432 {
 433     TimeValue systime;
 434     osl_getSystemTime(&systime);
 435
 436     sal_Int64 lastCheck = systime.Seconds;
 437
 438     replaceByName(UNISTRING(LAST_CHECK), uno::makeAny(lastCheck));
 439 }
 440
 441 //------------------------------------------------------------------------------
 442
 443 void
 444 UpdateCheckConfig::storeUpdateFound( const UpdateInfo& rInfo, const rtl::OUString& aCurrentBuild)
 445
 446 {
 447     bool autoDownloadEnabled = isAutoDownloadEnabled();
 448
 449     uno::Any aValues[nUpdateEntryProperties] =
 450     {
 451         uno::makeAny(rInfo.Version),
 452         uno::makeAny(rInfo.BuildId),
 453         uno::makeAny(rInfo.Description),
 454         uno::makeAny(rInfo.Sources[0].URL),
 455         uno::makeAny(rInfo.Sources[0].IsDirect ? sal_True : sal_False),
 456         uno::makeAny(getReleaseNote(rInfo, 1, autoDownloadEnabled) ),
 457         uno::makeAny(getReleaseNote(rInfo, 2, autoDownloadEnabled) ),
 458         uno::makeAny(getReleaseNote(rInfo, 3, autoDownloadEnabled) ),
 459         uno::makeAny(getReleaseNote(rInfo, 4, autoDownloadEnabled) ),
 460         uno::makeAny(getReleaseNote(rInfo, 5, autoDownloadEnabled) ),
 461         uno::makeAny(aCurrentBuild)
 462     };
 463
 464     rtl::OUString aName;
 465     for( sal_uInt32 n=0; n < nUpdateEntryProperties; ++n )
 466     {
 467         aName = rtl::OUString::createFromAscii(aUpdateEntryProperties[n]);
 468
 469         if( m_xContainer->hasByName(aName) )
 470             m_xContainer->replaceByName(aName, aValues[n]);
 471         else
 472             m_xContainer->insertByName(aName,aValues[n]);
 473     }
 474
 475     commitChanges();
 476 }
 477
 478 //------------------------------------------------------------------------------
 479
 480 void
 481 UpdateCheckConfig::clearUpdateFound()
 482 {
 483     rtl::OUString aName;
 484
 485     for( sal_uInt32 n=0; n < nUpdateEntryProperties; ++n )
 486     {
 487         aName = rtl::OUString::createFromAscii(aUpdateEntryProperties[n]);
 488
 489         try {
 490             if( m_xContainer->hasByName(aName) )
 491                 m_xContainer->removeByName(aName);
 492         } catch(const lang::WrappedTargetException& ) {
 493             // Can not remove value, probably in share layer
 494             OSL_ASSERT(false);
 495             m_xContainer->replaceByName(aName, uno::makeAny(rtl::OUString()));
 496         }
 497     }
 498
 499     /* As we have removed UpdateVersionFound from the shared configuration
 500      * existing entries in the user layer do not have a oor operation and
 501      * thus are completly ignored (which also means they can not be removed).
 502      */
 503
 504     commitChanges();
 505 }
 506
 507 //------------------------------------------------------------------------------
 508
 509 uno::Sequence< rtl::OUString >
 510 UpdateCheckConfig::getServiceNames()
 511 {
 512     uno::Sequence< rtl::OUString > aServiceList(1);
 513     aServiceList[0] = UNISTRING( "com.sun.star.setup.UpdateCheckConfig");
 514     return aServiceList;
 515 }
 516
 517 //------------------------------------------------------------------------------
 518
 519 rtl::OUString
 520 UpdateCheckConfig::getImplName()
 521 {
 522     return UNISTRING( "vnd.sun.UpdateCheckConfig");
 523 }
 524
 525 //------------------------------------------------------------------------------
 526
 527 uno::Type SAL_CALL
 528 UpdateCheckConfig::getElementType() throw (uno::RuntimeException)
 529 {
 530     return m_xContainer->getElementType();
 531 }
 532
 533 //------------------------------------------------------------------------------
 534
 535 sal_Bool SAL_CALL
 536 UpdateCheckConfig::hasElements() throw (uno::RuntimeException)
 537 {
 538     return m_xContainer->hasElements();
 539 }
 540
 541 //------------------------------------------------------------------------------
 542
 543 uno::Any SAL_CALL
 544 UpdateCheckConfig::getByName( const ::rtl::OUString& aName )
 545     throw (container::NoSuchElementException, lang::WrappedTargetException,  uno::RuntimeException)
 546 {
 547     uno::Any aValue = m_xContainer->getByName( aName );
 548
 549     // Provide dynamic default value
 550     if( aName.equalsAscii(DOWNLOAD_DESTINATION) )
 551     {
 552         rtl::OUString aStr;
 553         aValue >>= aStr;
 554
 555         if( aStr.isEmpty() )
 556             aValue = uno::makeAny(getDesktopDirectory());
 557     }
 558
 559     return aValue;
 560 }
 561
 562 //------------------------------------------------------------------------------
 563
 564 uno::Sequence< ::rtl::OUString > SAL_CALL
 565 UpdateCheckConfig::getElementNames(  ) throw (uno::RuntimeException)
 566 {
 567     return m_xContainer->getElementNames();
 568 }
 569
 570 //------------------------------------------------------------------------------
 571
 572 sal_Bool SAL_CALL
 573 UpdateCheckConfig::hasByName( const ::rtl::OUString& aName ) throw (uno::RuntimeException)
 574 {
 575     return m_xContainer->hasByName( aName );
 576 }
 577
 578 //------------------------------------------------------------------------------
 579
 580 void SAL_CALL
 581 UpdateCheckConfig::replaceByName( const ::rtl::OUString& aName, const uno::Any& aElement )
 582     throw (lang::IllegalArgumentException, container::NoSuchElementException,
 583            lang::WrappedTargetException, uno::RuntimeException)
 584 {
 585     return m_xContainer->replaceByName( aName, aElement );
 586 }
 587
 588 //------------------------------------------------------------------------------
 589 // XChangesBatch
 590
 591 void SAL_CALL
 592 UpdateCheckConfig::commitChanges()
 593     throw (lang::WrappedTargetException, uno::RuntimeException)
 594 {
 595     uno::Reference< util::XChangesBatch > xChangesBatch(m_xContainer, uno::UNO_QUERY);
 596     if( xChangesBatch.is() && xChangesBatch->hasPendingChanges() )
 597     {
 598         util::ChangesSet aChangesSet = xChangesBatch->getPendingChanges();
 599         xChangesBatch->commitChanges();
 600
 601         if( m_rListener.is() )
 602         {
 603             const sal_Int32 nChanges = aChangesSet.getLength();
 604             rtl::OUString aString;
 605
 606             for( sal_Int32 i=0; i<nChanges; ++i )
 607             {
 608                 aChangesSet[i].Accessor >>= aString;
 609
 610                 // FIXME: use non IgnoreAsciiCase version as soon as it becomes available
 611                 if( aString.endsWithIgnoreAsciiCaseAsciiL(AUTOCHECK_ENABLED "']", sizeof(AUTOCHECK_ENABLED)+1) )
 612                 {
 613                     sal_Bool bEnabled = sal_False;
 614                     aChangesSet[i].Element >>= bEnabled;
 615                     m_rListener->autoCheckStatusChanged(sal_True == bEnabled);
 616                 }
 617                 // FIXME: use non IgnoreAsciiCase version as soon as it becomes available
 618                 else if( aString.endsWithIgnoreAsciiCaseAsciiL(CHECK_INTERVAL "']", sizeof(CHECK_INTERVAL)+1) )
 619                 {
 620                     m_rListener->autoCheckIntervalChanged();
 621                 }
 622             }
 623         }
 624     }
 625
 626     xChangesBatch = uno::Reference< util::XChangesBatch > ( m_xAvailableUpdates, uno::UNO_QUERY );
 627     if( xChangesBatch.is() && xChangesBatch->hasPendingChanges() )
 628     {
 629         util::ChangesSet aChangesSet = xChangesBatch->getPendingChanges();
 630         xChangesBatch->commitChanges();
 631     }
 632     xChangesBatch = uno::Reference< util::XChangesBatch > ( m_xIgnoredUpdates, uno::UNO_QUERY );
 633     if( xChangesBatch.is() && xChangesBatch->hasPendingChanges() )
 634     {
 635         util::ChangesSet aChangesSet = xChangesBatch->getPendingChanges();
 636         xChangesBatch->commitChanges();
 637     }
 638 }
 639
 640 //------------------------------------------------------------------------------
 641
 642 sal_Bool SAL_CALL
 643 UpdateCheckConfig::hasPendingChanges(  ) throw (uno::RuntimeException)
 644 {
 645     uno::Reference< util::XChangesBatch > xChangesBatch(m_xContainer, uno::UNO_QUERY);
 646     if( xChangesBatch.is() )
 647         return xChangesBatch->hasPendingChanges();
 648
 649     return sal_False;
 650 }
 651
 652 //------------------------------------------------------------------------------
 653
 654 uno::Sequence< util::ElementChange > SAL_CALL
 655 UpdateCheckConfig::getPendingChanges(  ) throw (uno::RuntimeException)
 656 {
 657     uno::Reference< util::XChangesBatch > xChangesBatch(m_xContainer, uno::UNO_QUERY);
 658     if( xChangesBatch.is() )
 659         return xChangesBatch->getPendingChanges();
 660
 661     return uno::Sequence< util::ElementChange >();
 662 }
 663
 664 //------------------------------------------------------------------------------
 665 bool UpdateCheckConfig::storeExtensionVersion( const rtl::OUString& rExtensionName,
 666                                                const rtl::OUString& rVersion )
 667 {
 668     bool bNotify = true;
 669
 670     if ( m_xAvailableUpdates->hasByName( rExtensionName ) )
 671         uno::Reference< beans::XPropertySet >( m_xAvailableUpdates->getByName( rExtensionName ), uno::UNO_QUERY_THROW )->setPropertyValue( PROPERTY_VERSION, uno::Any( rVersion ) );
 672     else
 673     {
 674         uno::Reference< beans::XPropertySet > elem( uno::Reference< lang::XSingleServiceFactory >( m_xAvailableUpdates, uno::UNO_QUERY_THROW )->createInstance(), uno::UNO_QUERY_THROW );
 675         elem->setPropertyValue( PROPERTY_VERSION, uno::Any( rVersion ) );
 676         m_xAvailableUpdates->insertByName( rExtensionName, uno::Any( elem ) );
 677     }
 678
 679     if ( m_xIgnoredUpdates->hasByName( rExtensionName ) )
 680     {
 681         ::rtl::OUString aIgnoredVersion;
 682         uno::Any aValue( uno::Reference< beans::XPropertySet >( m_xIgnoredUpdates->getByName( rExtensionName ), uno::UNO_QUERY_THROW )->getPropertyValue( PROPERTY_VERSION ) );
 683         aValue >>= aIgnoredVersion;
 684         if ( aIgnoredVersion.isEmpty() ) // no version means ignore all updates
 685             bNotify = false;
 686         else if ( aIgnoredVersion == rVersion ) // the user wanted to ignore this update
 687             bNotify = false;
 688     }
 689
 690     commitChanges();
 691
 692     return bNotify;
 693 }
 694
 695 //------------------------------------------------------------------------------
 696 bool UpdateCheckConfig::checkExtensionVersion( const rtl::OUString& rExtensionName,
 697                                                const rtl::OUString& rVersion )
 698 {
 699     if ( m_xAvailableUpdates->hasByName( rExtensionName ) )
 700     {
 701         ::rtl::OUString aStoredVersion;
 702         uno::Any aValue( uno::Reference< beans::XPropertySet >( m_xAvailableUpdates->getByName( rExtensionName ), uno::UNO_QUERY_THROW )->getPropertyValue( PROPERTY_VERSION ) );
 703         aValue >>= aStoredVersion;
 704
 705         if ( m_xIgnoredUpdates->hasByName( rExtensionName ) )
 706         {
 707             ::rtl::OUString aIgnoredVersion;
 708             uno::Any aValue2( uno::Reference< beans::XPropertySet >( m_xIgnoredUpdates->getByName( rExtensionName ), uno::UNO_QUERY_THROW )->getPropertyValue( PROPERTY_VERSION ) );
 709             aValue2 >>= aIgnoredVersion;
 710             if ( aIgnoredVersion.isEmpty() ) // no version means ignore all updates
 711                 return false;
 712             else if ( aIgnoredVersion == aStoredVersion ) // the user wanted to ignore this update
 713                 return false;
 714             // TODO: else delete ignored entry?
 715         }
 716         if ( isVersionGreater( rVersion, aStoredVersion ) )
 717             return true;
 718         else
 719         {
 720             m_xAvailableUpdates->removeByName( rExtensionName );
 721             commitChanges();
 722         }
 723     }
 724
 725     return false;
 726 }
 727
 728 //------------------------------------------------------------------------------
 729 rtl::OUString UpdateCheckConfig::getSubVersion( const rtl::OUString& rVersion,
 730                                                 sal_Int32 *nIndex )
 731 {
 732     while ( *nIndex < rVersion.getLength() && rVersion[*nIndex] == '0')
 733     {
 734         ++*nIndex;
 735     }
 736
 737     return rVersion.getToken( 0, '.', *nIndex );
 738 }
 739
 740 //------------------------------------------------------------------------------
 741 // checks if the second version string is greater than the first one
 742
 743 bool UpdateCheckConfig::isVersionGreater( const rtl::OUString& rVersion1,
 744                                           const rtl::OUString& rVersion2 )
 745 {
 746     for ( sal_Int32 i1 = 0, i2 = 0; i1 >= 0 || i2 >= 0; )
 747     {
 748         ::rtl::OUString sSub1( getSubVersion( rVersion1, &i1 ) );
 749         ::rtl::OUString sSub2( getSubVersion( rVersion2, &i2 ) );
 750
 751         if ( sSub1.getLength() < sSub2.getLength() ) {
 752             return true;
 753         } else if ( sSub1.getLength() > sSub2.getLength() ) {
 754             return false;
 755         } else if ( sSub1 < sSub2 ) {
 756             return true;
 757         } else if ( sSub1 > sSub2 ) {
 758             return false;
 759         }
 760     }
 761     return false;
 762 }
 763
 764 //------------------------------------------------------------------------------
 765 //------------------------------------------------------------------------------
 766 //------------------------------------------------------------------------------
 767
 768 rtl::OUString SAL_CALL
 769 UpdateCheckConfig::getImplementationName()  throw (uno::RuntimeException)
 770 {
 771     return getImplName();
 772 }
 773
 774 //------------------------------------------------------------------------------
 775
 776 sal_Bool SAL_CALL
 777 UpdateCheckConfig::supportsService(rtl::OUString const & serviceName)
 778     throw (uno::RuntimeException)
 779 {
 780     uno::Sequence< rtl::OUString > aServiceNameList = getServiceNames();
 781
 782     for( sal_Int32 n=0; n < aServiceNameList.getLength(); n++ )
 783         if( aServiceNameList[n].equals(serviceName) )
 784             return sal_True;
 785
 786     return sal_False;
 787 }
 788
 789 //------------------------------------------------------------------------------
 790
 791 uno::Sequence< rtl::OUString > SAL_CALL
 792 UpdateCheckConfig::getSupportedServiceNames()  throw (uno::RuntimeException)
 793 {
 794     return getServiceNames();
 795 }
 796
 797
 798 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */