/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_extensions.hxx"
#include "updatecheckconfig.hxx"
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/XPropertyState.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/lang/XSingleServiceFactory.hpp>
#include <osl/security.hxx>
#include <osl/time.h>
#include <osl/file.hxx>
#ifdef WNT
#ifdef _MSC_VER
#pragma warning(push,1) // disable warnings within system headers
#pragma warning(disable: 4917)
#endif
#include <shlobj.h>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif
namespace container = com::sun::star::container ;
namespace beans = com::sun::star::beans ;
namespace lang = com::sun::star::lang ;
namespace util = com::sun::star::util ;
namespace uno = com::sun::star::uno ;
#define UNISTRING(s) rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(s))
#define LAST_CHECK "LastCheck"
#define VERSION_FOUND "UpdateVersionFound"
#define UPDATE_VERSION "UpdateVersion"
#define UPDATE_BUILDID "UpdateBuildId"
#define UPDATE_DESCRIPTION "UpdateDescription"
#define DOWNLOAD_URL "DownloadURL"
#define IS_DIRECT_DOWNLOAD "IsDirectDownload"
#define OLD_VERSION "UpdateFoundFor"
#define AUTOCHECK_ENABLED "AutoCheckEnabled"
#define AUTODOWNLOAD_ENABLED "AutoDownloadEnabled"
#define CHECK_INTERVAL "CheckInterval"
#define LOCAL_FILE "LocalFile"
#define DOWNLOAD_SIZE "DownloadSize"
#define DOWNLOAD_PAUSED "DownloadPaused"
#define DOWNLOAD_DESTINATION "DownloadDestination"
#define RELEASE_NOTE "ReleaseNote"
#define EXTENSION_PREFIX "Extension_"
#define PROPERTY_VERSION UNISTRING("Version")
static const sal_Char * const aUpdateEntryProperties[] = {
UPDATE_VERSION,
UPDATE_BUILDID,
UPDATE_DESCRIPTION,
DOWNLOAD_URL,
IS_DIRECT_DOWNLOAD,
RELEASE_NOTE"1",
RELEASE_NOTE"2",
RELEASE_NOTE"3",
RELEASE_NOTE"4",
RELEASE_NOTE"5",
OLD_VERSION
};
static const sal_uInt32 nUpdateEntryProperties = sizeof(aUpdateEntryProperties) / sizeof(sal_Char *);
//------------------------------------------------------------------------------
NamedValueByNameAccess::~NamedValueByNameAccess()
{
}
//------------------------------------------------------------------------------
::com::sun::star::uno::Any
NamedValueByNameAccess::getValue(const sal_Char * pName)
{
const sal_Int32 nLen = m_rValues.getLength();
for( sal_Int32 n=0; n < nLen; ++n )
{
if( m_rValues[n].Name.equalsAscii( pName ) )
return m_rValues[n].Value;
}
return ::com::sun::star::uno::Any();
}
//------------------------------------------------------------------------------
bool
UpdateCheckROModel::isAutoCheckEnabled() const
{
return sal_True == m_aNameAccess.getValue(AUTOCHECK_ENABLED).get< sal_Bool >();
}
//------------------------------------------------------------------------------
bool
UpdateCheckROModel::isDownloadPaused() const
{
return sal_True == m_aNameAccess.getValue(DOWNLOAD_PAUSED).get< sal_Bool >();
}
//------------------------------------------------------------------------------
rtl::OUString
UpdateCheckROModel::getStringValue(const sal_Char * pStr) const
{
uno::Any aAny( m_aNameAccess.getValue(pStr) );
rtl::OUString aRet;
aAny >>= aRet;
return aRet;
}
//------------------------------------------------------------------------------
rtl::OUString UpdateCheckROModel::getLocalFileName() const
{
return getStringValue(LOCAL_FILE);
};
//------------------------------------------------------------------------------
sal_Int64 UpdateCheckROModel::getDownloadSize() const
{
uno::Any aAny( m_aNameAccess.getValue(DOWNLOAD_SIZE) );
sal_Int64 nRet = -1;
aAny >>= nRet;
return nRet;
};
//------------------------------------------------------------------------------
rtl::OUString
UpdateCheckROModel::getUpdateEntryVersion() const
{
return getStringValue(OLD_VERSION);
}
//------------------------------------------------------------------------------
void
UpdateCheckROModel::getUpdateEntry(UpdateInfo& rInfo) const
{
rInfo.BuildId = getStringValue(UPDATE_BUILDID);
rInfo.Version = getStringValue(UPDATE_VERSION);
rInfo.Description = getStringValue(UPDATE_DESCRIPTION);
sal_Bool isDirectDownload = sal_False;
m_aNameAccess.getValue(IS_DIRECT_DOWNLOAD) >>= isDirectDownload;
rInfo.Sources.push_back( DownloadSource( isDirectDownload, getStringValue(DOWNLOAD_URL) ) );
rtl::OString aStr(RELEASE_NOTE);
for(sal_Int32 n=1; n < 6; ++n )
{
rtl::OUString aUStr = getStringValue( (aStr + rtl::OString::valueOf(n)).getStr());
if( aUStr.getLength() > 0 )
rInfo.ReleaseNotes.push_back(ReleaseNote((sal_Int8) n, aUStr));
}
}
//------------------------------------------------------------------------------
rtl::OUString UpdateCheckConfig::getDesktopDirectory()
{
rtl::OUString aRet;
#ifdef WNT
WCHAR szPath[MAX_PATH];
if( ! FAILED( SHGetSpecialFolderPathW( NULL, szPath, CSIDL_DESKTOPDIRECTORY, true ) ) )
{
aRet = rtl::OUString( reinterpret_cast< sal_Unicode * >(szPath) );
osl::FileBase::getFileURLFromSystemPath( aRet, aRet );
}
#else
// This should become a desktop specific setting in some system backend ..
rtl::OUString aHomeDir;
osl::Security().getHomeDir( aHomeDir );
aRet = aHomeDir + rtl::OUString::createFromAscii("/Desktop");
// Set path to home directory when there is no /Desktop directory
osl::Directory aDocumentsDir( aRet );
if( osl::FileBase::E_None != aDocumentsDir.open() )
aRet = aHomeDir;
#endif
return aRet;
}
//------------------------------------------------------------------------------
rtl::OUString UpdateCheckConfig::getAllUsersDirectory()
{
rtl::OUString aRet;
#ifdef WNT
WCHAR szPath[MAX_PATH];
if( ! FAILED( SHGetSpecialFolderPathW( NULL, szPath, CSIDL_COMMON_DOCUMENTS, true ) ) )
{
aRet = rtl::OUString( reinterpret_cast< sal_Unicode * >(szPath) );
osl::FileBase::RC rc;
rc = osl::FileBase::getFileURLFromSystemPath( aRet, aRet );
}
#else
osl::FileBase::getTempDirURL(aRet);
#endif
return aRet;
}
//------------------------------------------------------------------------------
UpdateCheckConfig::UpdateCheckConfig( const uno::Reference<container::XNameContainer>& xContainer,
const uno::Reference<container::XNameContainer>& xAvailableUpdates,
const uno::Reference<container::XNameContainer>& xIgnoredUpdates,
const ::rtl::Reference< UpdateCheckConfigListener >& rListener ) :
m_xContainer( xContainer ),
m_xAvailableUpdates( xAvailableUpdates ),
m_xIgnoredUpdates( xIgnoredUpdates ),
m_rListener( rListener )
{}
//------------------------------------------------------------------------------
UpdateCheckConfig::~UpdateCheckConfig()
{}
//------------------------------------------------------------------------------
::rtl::Reference< UpdateCheckConfig >
UpdateCheckConfig::get(
const uno::Reference<uno::XComponentContext>& xContext,
const ::rtl::Reference< UpdateCheckConfigListener >& rListener)
{
if( !xContext.is() )
throw uno::RuntimeException(
UNISTRING( "UpdateCheckConfig: empty component context" ),
uno::Reference< uno::XInterface >() );
uno::Reference< lang::XMultiComponentFactory > xServiceManager(xContext->getServiceManager());
if( !xServiceManager.is() )
throw uno::RuntimeException(
UNISTRING( "UpdateCheckConfig: unable to obtain service manager from component context" ),
uno::Reference< uno::XInterface >() );
uno::Reference< lang::XMultiServiceFactory > xConfigProvider(
xServiceManager->createInstanceWithContext( UNISTRING( "com.sun.star.configuration.ConfigurationProvider" ), xContext ),
uno::UNO_QUERY_THROW);
beans::PropertyValue aProperty;
aProperty.Name = UNISTRING( "nodepath" );
aProperty.Value = uno::makeAny( UNISTRING("org.openoffice.Office.Jobs/Jobs/UpdateCheck/Arguments") );
uno::Sequence< uno::Any > aArgumentList( 1 );
aArgumentList[0] = uno::makeAny( aProperty );
uno::Reference< container::XNameContainer > xContainer(
xConfigProvider->createInstanceWithArguments(
UNISTRING("com.sun.star.configuration.ConfigurationUpdateAccess"), aArgumentList ),
uno::UNO_QUERY_THROW );
aProperty.Value = uno::makeAny( UNISTRING("/org.openoffice.Office.ExtensionManager/ExtensionUpdateData/IgnoredUpdates") );
aArgumentList[0] = uno::makeAny( aProperty );
uno::Reference< container::XNameContainer > xIgnoredExt( xConfigProvider->createInstanceWithArguments( UNISTRING("com.sun.star.configuration.ConfigurationUpdateAccess"), aArgumentList ), uno::UNO_QUERY_THROW );
aProperty.Value = uno::makeAny( UNISTRING("/org.openoffice.Office.ExtensionManager/ExtensionUpdateData/AvailableUpdates") );
aArgumentList[0] = uno::makeAny( aProperty );
uno::Reference< container::XNameContainer > xUpdateAvail( xConfigProvider->createInstanceWithArguments( UNISTRING("com.sun.star.configuration.ConfigurationUpdateAccess"), aArgumentList ), uno::UNO_QUERY_THROW );
return new UpdateCheckConfig( xContainer, xUpdateAvail, xIgnoredExt, rListener );
}
//------------------------------------------------------------------------------
bool
UpdateCheckConfig::isAutoCheckEnabled() const
{
sal_Bool nValue = sal_False;
const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( AUTOCHECK_ENABLED ) ) >>= nValue;
return nValue;
}
//------------------------------------------------------------------------------
bool
UpdateCheckConfig::isAutoDownloadEnabled() const
{
sal_Bool nValue = sal_False;
const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( AUTODOWNLOAD_ENABLED ) ) >>= nValue;
return nValue;
}
//------------------------------------------------------------------------------
rtl::OUString
UpdateCheckConfig::getUpdateEntryVersion() const
{
rtl::OUString aValue;
// getByName is defined as non const in XNameAccess
const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( OLD_VERSION ) ) >>= aValue;
return aValue;
}
//------------------------------------------------------------------------------
sal_Int64
UpdateCheckConfig::getLastChecked() const
{
sal_Int64 nValue = 0;
// getByName is defined as non const in XNameAccess
const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( LAST_CHECK ) ) >>= nValue;
return nValue;
}
//------------------------------------------------------------------------------
sal_Int64
UpdateCheckConfig::getCheckInterval() const
{
sal_Int64 nValue = 0;
// getByName is defined as non const in XNameAccess
const_cast < UpdateCheckConfig *> (this)->getByName( UNISTRING( CHECK_INTERVAL ) ) >>= nValue;
return nValue;
}
//------------------------------------------------------------------------------
rtl::OUString
UpdateCheckConfig::getLocalFileName() const
{
rtl::OUString aName = UNISTRING(LOCAL_FILE);
rtl::OUString aRet;
if( m_xContainer->hasByName(aName) )
m_xContainer->getByName(aName) >>= aRet;
return aRet;
}
//------------------------------------------------------------------------------
rtl::OUString
UpdateCheckConfig::getDownloadDestination() const
{
rtl::OUString aName = UNISTRING(DOWNLOAD_DESTINATION);
rtl::OUString aRet;
const_cast <UpdateCheckConfig *> (this)->getByName(aName) >>= aRet;
return aRet;
}
//------------------------------------------------------------------------------
void
UpdateCheckConfig::storeLocalFileName(const rtl::OUString& rLocalFileName, sal_Int64 nFileSize)
{
const sal_uInt8 nItems = 2;
const rtl::OUString aNameList[nItems] = { UNISTRING(LOCAL_FILE), UNISTRING(DOWNLOAD_SIZE) };
const uno::Any aValueList[nItems] = { uno::makeAny(rLocalFileName), uno::makeAny(nFileSize) };
for( sal_uInt8 i=0; i < nItems; ++i )
{
if( m_xContainer->hasByName(aNameList[i]) )
m_xContainer->replaceByName(aNameList[i], aValueList[i]);
else
m_xContainer->insertByName(aNameList[i], aValueList[i]);
}
commitChanges();
}
//------------------------------------------------------------------------------
void
UpdateCheckConfig::clearLocalFileName()
{
const sal_uInt8 nItems = 2;
const rtl::OUString aNameList[nItems] = { UNISTRING(LOCAL_FILE), UNISTRING(DOWNLOAD_SIZE) };
for( sal_uInt8 i=0; i < nItems; ++i )
{
if( m_xContainer->hasByName(aNameList[i]) )
m_xContainer->removeByName(aNameList[i]);
}
commitChanges();
}
//------------------------------------------------------------------------------
void
UpdateCheckConfig::storeDownloadPaused(bool paused)
{
replaceByName(UNISTRING(DOWNLOAD_PAUSED) , uno::makeAny(paused));
commitChanges();
}
//------------------------------------------------------------------------------
void
UpdateCheckConfig::updateLastChecked()
{
TimeValue systime;
osl_getSystemTime(&systime);
sal_Int64 lastCheck = systime.Seconds;
replaceByName(UNISTRING(LAST_CHECK), uno::makeAny(lastCheck));
}
//------------------------------------------------------------------------------
void
UpdateCheckConfig::storeUpdateFound( const UpdateInfo& rInfo, const rtl::OUString& aCurrentBuild)
{
bool autoDownloadEnabled = isAutoDownloadEnabled();
uno::Any aValues[nUpdateEntryProperties] =
{
uno::makeAny(rInfo.Version),
uno::makeAny(rInfo.BuildId),
uno::makeAny(rInfo.Description),
uno::makeAny(rInfo.Sources[0].URL),
uno::makeAny(rInfo.Sources[0].IsDirect ? sal_True : sal_False),
uno::makeAny(getReleaseNote(rInfo, 1, autoDownloadEnabled) ),
uno::makeAny(getReleaseNote(rInfo, 2, autoDownloadEnabled) ),
uno::makeAny(getReleaseNote(rInfo, 3, autoDownloadEnabled) ),
uno::makeAny(getReleaseNote(rInfo, 4, autoDownloadEnabled) ),
uno::makeAny(getReleaseNote(rInfo, 5, autoDownloadEnabled) ),
uno::makeAny(aCurrentBuild)
};
rtl::OUString aName;
for( sal_uInt32 n=0; n < nUpdateEntryProperties; ++n )
{
aName = rtl::OUString::createFromAscii(aUpdateEntryProperties[n]);
if( m_xContainer->hasByName(aName) )
m_xContainer->replaceByName(aName, aValues[n]);
else
m_xContainer->insertByName(aName,aValues[n]);
}
commitChanges();
}
//------------------------------------------------------------------------------
void
UpdateCheckConfig::clearUpdateFound()
{
rtl::OUString aName;
for( sal_uInt32 n=0; n < nUpdateEntryProperties; ++n )
{
aName = rtl::OUString::createFromAscii(aUpdateEntryProperties[n]);
try {
if( m_xContainer->hasByName(aName) )
m_xContainer->removeByName(aName);
} catch(const lang::WrappedTargetException& ) {
// Can not remove value, probably in share layer
OSL_ASSERT(false);
m_xContainer->replaceByName(aName, uno::makeAny(rtl::OUString()));
}
}
/* As we have removed UpdateVersionFound from the shared configuration
* existing entries in the user layer do not have a oor operation and
* thus are completly ignored (which also means they can not be removed).
*/
commitChanges();
}
//------------------------------------------------------------------------------
uno::Sequence< rtl::OUString >
UpdateCheckConfig::getServiceNames()
{
uno::Sequence< rtl::OUString > aServiceList(1);
aServiceList[0] = UNISTRING( "com.sun.star.setup.UpdateCheckConfig");
return aServiceList;
}
//------------------------------------------------------------------------------
rtl::OUString
UpdateCheckConfig::getImplName()
{
return UNISTRING( "vnd.sun.UpdateCheckConfig");
}
//------------------------------------------------------------------------------
uno::Type SAL_CALL
UpdateCheckConfig::getElementType() throw (uno::RuntimeException)
{
return m_xContainer->getElementType();
}
//------------------------------------------------------------------------------
sal_Bool SAL_CALL
UpdateCheckConfig::hasElements() throw (uno::RuntimeException)
{
return m_xContainer->hasElements();
}
//------------------------------------------------------------------------------
uno::Any SAL_CALL
UpdateCheckConfig::getByName( const ::rtl::OUString& aName )
throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
{
uno::Any aValue = m_xContainer->getByName( aName );
// Provide dynamic default value
if( aName.equalsAscii(DOWNLOAD_DESTINATION) )
{
rtl::OUString aStr;
aValue >>= aStr;
if( aStr.getLength() == 0 )
aValue = uno::makeAny(getDesktopDirectory());
}
return aValue;
}
//------------------------------------------------------------------------------
uno::Sequence< ::rtl::OUString > SAL_CALL
UpdateCheckConfig::getElementNames( ) throw (uno::RuntimeException)
{
return m_xContainer->getElementNames();
}
//------------------------------------------------------------------------------
sal_Bool SAL_CALL
UpdateCheckConfig::hasByName( const ::rtl::OUString& aName ) throw (uno::RuntimeException)
{
return m_xContainer->hasByName( aName );
}
//------------------------------------------------------------------------------
void SAL_CALL
UpdateCheckConfig::replaceByName( const ::rtl::OUString& aName, const uno::Any& aElement )
throw (lang::IllegalArgumentException, container::NoSuchElementException,
lang::WrappedTargetException, uno::RuntimeException)
{
return m_xContainer->replaceByName( aName, aElement );
}
//------------------------------------------------------------------------------
// XChangesBatch
void SAL_CALL
UpdateCheckConfig::commitChanges()
throw (lang::WrappedTargetException, uno::RuntimeException)
{
uno::Reference< util::XChangesBatch > xChangesBatch(m_xContainer, uno::UNO_QUERY);
if( xChangesBatch.is() && xChangesBatch->hasPendingChanges() )
{
util::ChangesSet aChangesSet = xChangesBatch->getPendingChanges();
xChangesBatch->commitChanges();
if( m_rListener.is() )
{
const sal_Int32 nChanges = aChangesSet.getLength();
rtl::OUString aString;
for( sal_Int32 i=0; i<nChanges; ++i )
{
aChangesSet[i].Accessor >>= aString;
// FIXME: use non IgnoreAsciiCase version as soon as it becomes available
if( aString.endsWithIgnoreAsciiCaseAsciiL(AUTOCHECK_ENABLED "']", sizeof(AUTOCHECK_ENABLED)+1) )
{
sal_Bool bEnabled = sal_False;
aChangesSet[i].Element >>= bEnabled;
m_rListener->autoCheckStatusChanged(sal_True == bEnabled);
}
// FIXME: use non IgnoreAsciiCase version as soon as it becomes available
else if( aString.endsWithIgnoreAsciiCaseAsciiL(CHECK_INTERVAL "']", sizeof(CHECK_INTERVAL)+1) )
{
m_rListener->autoCheckIntervalChanged();
}
}
}
}
xChangesBatch = uno::Reference< util::XChangesBatch > ( m_xAvailableUpdates, uno::UNO_QUERY );
if( xChangesBatch.is() && xChangesBatch->hasPendingChanges() )
{
util::ChangesSet aChangesSet = xChangesBatch->getPendingChanges();
xChangesBatch->commitChanges();
}
xChangesBatch = uno::Reference< util::XChangesBatch > ( m_xIgnoredUpdates, uno::UNO_QUERY );
if( xChangesBatch.is() && xChangesBatch->hasPendingChanges() )
{
util::ChangesSet aChangesSet = xChangesBatch->getPendingChanges();
xChangesBatch->commitChanges();
}
}
//------------------------------------------------------------------------------
sal_Bool SAL_CALL
UpdateCheckConfig::hasPendingChanges( ) throw (uno::RuntimeException)
{
uno::Reference< util::XChangesBatch > xChangesBatch(m_xContainer, uno::UNO_QUERY);
if( xChangesBatch.is() )
return xChangesBatch->hasPendingChanges();
return sal_False;
}
//------------------------------------------------------------------------------
uno::Sequence< util::ElementChange > SAL_CALL
UpdateCheckConfig::getPendingChanges( ) throw (uno::RuntimeException)
{
uno::Reference< util::XChangesBatch > xChangesBatch(m_xContainer, uno::UNO_QUERY);
if( xChangesBatch.is() )
return xChangesBatch->getPendingChanges();
return uno::Sequence< util::ElementChange >();
}
//------------------------------------------------------------------------------
bool UpdateCheckConfig::storeExtensionVersion( const rtl::OUString& rExtensionName,
const rtl::OUString& rVersion )
{
bool bNotify = true;
if ( m_xAvailableUpdates->hasByName( rExtensionName ) )
uno::Reference< beans::XPropertySet >( m_xAvailableUpdates->getByName( rExtensionName ), uno::UNO_QUERY_THROW )->setPropertyValue( PROPERTY_VERSION, uno::Any( rVersion ) );
else
{
uno::Reference< beans::XPropertySet > elem( uno::Reference< lang::XSingleServiceFactory >( m_xAvailableUpdates, uno::UNO_QUERY_THROW )->createInstance(), uno::UNO_QUERY_THROW );
elem->setPropertyValue( PROPERTY_VERSION, uno::Any( rVersion ) );
m_xAvailableUpdates->insertByName( rExtensionName, uno::Any( elem ) );
}
if ( m_xIgnoredUpdates->hasByName( rExtensionName ) )
{
::rtl::OUString aIgnoredVersion;
uno::Any aValue( uno::Reference< beans::XPropertySet >( m_xIgnoredUpdates->getByName( rExtensionName ), uno::UNO_QUERY_THROW )->getPropertyValue( PROPERTY_VERSION ) );
aValue >>= aIgnoredVersion;
if ( aIgnoredVersion.getLength() == 0 ) // no version means ignore all updates
bNotify = false;
else if ( aIgnoredVersion == rVersion ) // the user wanted to ignore this update
bNotify = false;
}
commitChanges();
return bNotify;
}
//------------------------------------------------------------------------------
bool UpdateCheckConfig::checkExtensionVersion( const rtl::OUString& rExtensionName,
const rtl::OUString& rVersion )
{
if ( m_xAvailableUpdates->hasByName( rExtensionName ) )
{
::rtl::OUString aStoredVersion;
uno::Any aValue( uno::Reference< beans::XPropertySet >( m_xAvailableUpdates->getByName( rExtensionName ), uno::UNO_QUERY_THROW )->getPropertyValue( PROPERTY_VERSION ) );
aValue >>= aStoredVersion;
if ( m_xIgnoredUpdates->hasByName( rExtensionName ) )
{
::rtl::OUString aIgnoredVersion;
uno::Any aValue2( uno::Reference< beans::XPropertySet >( m_xIgnoredUpdates->getByName( rExtensionName ), uno::UNO_QUERY_THROW )->getPropertyValue( PROPERTY_VERSION ) );
aValue2 >>= aIgnoredVersion;
if ( aIgnoredVersion.getLength() == 0 ) // no version means ignore all updates
return false;
else if ( aIgnoredVersion == aStoredVersion ) // the user wanted to ignore this update
return false;
// TODO: else delete ignored entry?
}
if ( isVersionGreater( rVersion, aStoredVersion ) )
return true;
else
{
m_xAvailableUpdates->removeByName( rExtensionName );
commitChanges();
}
}
return false;
}
//------------------------------------------------------------------------------
rtl::OUString UpdateCheckConfig::getSubVersion( const rtl::OUString& rVersion,
sal_Int32 *nIndex )
{
while ( *nIndex < rVersion.getLength() && rVersion[*nIndex] == '0')
{
++*nIndex;
}
return rVersion.getToken( 0, '.', *nIndex );
}
//------------------------------------------------------------------------------
// checks if the second version string is greater than the first one
bool UpdateCheckConfig::isVersionGreater( const rtl::OUString& rVersion1,
const rtl::OUString& rVersion2 )
{
for ( sal_Int32 i1 = 0, i2 = 0; i1 >= 0 || i2 >= 0; )
{
::rtl::OUString sSub1( getSubVersion( rVersion1, &i1 ) );
::rtl::OUString sSub2( getSubVersion( rVersion2, &i2 ) );
if ( sSub1.getLength() < sSub2.getLength() ) {
return true;
} else if ( sSub1.getLength() > sSub2.getLength() ) {
return false;
} else if ( sSub1 < sSub2 ) {
return true;
} else if ( sSub1 > sSub2 ) {
return false;
}
}
return false;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
rtl::OUString SAL_CALL
UpdateCheckConfig::getImplementationName() throw (uno::RuntimeException)
{
return getImplName();
}
//------------------------------------------------------------------------------
sal_Bool SAL_CALL
UpdateCheckConfig::supportsService(rtl::OUString const & serviceName)
throw (uno::RuntimeException)
{
uno::Sequence< rtl::OUString > aServiceNameList = getServiceNames();
for( sal_Int32 n=0; n < aServiceNameList.getLength(); n++ )
if( aServiceNameList[n].equals(serviceName) )
return sal_True;
return sal_False;
}
//------------------------------------------------------------------------------
uno::Sequence< rtl::OUString > SAL_CALL
UpdateCheckConfig::getSupportedServiceNames() throw (uno::RuntimeException)
{
return getServiceNames();
}