?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump for 3.6-28
[LibreOffice.git] / extensions / source / update / check / updatecheck.cxx
blob7832d8c15d87c5e2403b9c64cbc43c3a8f58df29
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 #include "updatecheck.hxx"
31
32 #include <cppuhelper/implbase1.hxx>
33 #include <com/sun/star/beans/XFastPropertySet.hpp>
34 #include <com/sun/star/lang/XComponent.hpp>
35 #include <com/sun/star/frame/XDesktop.hpp>
36 #include <com/sun/star/frame/XFrame.hpp>
37 #include <com/sun/star/frame/DispatchResultEvent.hpp>
38 #include <com/sun/star/frame/DispatchResultState.hpp>
39 #include <com/sun/star/system/XSystemShellExecute.hpp>
40 #include <com/sun/star/system/SystemShellExecuteFlags.hpp>
41 #include <com/sun/star/task/XJob.hpp>
42 #include <com/sun/star/task/XJobExecutor.hpp>
43
44 #include <rtl/ustrbuf.hxx>
45
46 #include <rtl/bootstrap.hxx>
47 #include <osl/process.h>
48 #include <osl/module.hxx>
49 #include <osl/file.hxx>
50 #include <sal/macros.h>
51
52 #ifdef WNT
53 #ifdef _MSC_VER
54 #pragma warning(push,1) // disable warnings within system headers
55 //#pragma warning(disable: 4917)
56 #endif
57 #include <objbase.h>
58 #ifdef _MSC_VER
59 #pragma warning(pop)
60 #endif
61 #endif
62
63 #include "updateprotocol.hxx"
64 #include "updatecheckconfig.hxx"
65
66 namespace beans = com::sun::star::beans ;
67 namespace deployment = com::sun::star::deployment ;
68 namespace frame = com::sun::star::frame ;
69 namespace lang = com::sun::star::lang ;
70 namespace c3s = com::sun::star::system ;
71 namespace task = com::sun::star::task ;
72 namespace uno = com::sun::star::uno ;
73
74 #define UNISTRING(s) rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(s))
75
76 #define PROPERTY_TITLE UNISTRING("BubbleHeading")
77 #define PROPERTY_TEXT UNISTRING("BubbleText")
78 #define PROPERTY_IMAGE UNISTRING("BubbleImageURL")
79 #define PROPERTY_SHOW_BUBBLE UNISTRING("BubbleVisible")
80 #define PROPERTY_CLICK_HDL UNISTRING("MenuClickHDL")
81 #define PROPERTY_DEFAULT_TITLE UNISTRING("DefaultHeading")
82 #define PROPERTY_DEFAULT_TEXT UNISTRING("DefaultText")
83 #define PROPERTY_SHOW_MENUICON UNISTRING("MenuIconVisible")
84
85 extern "C" bool SAL_CALL WNT_hasInternetConnection();
86 //------------------------------------------------------------------------------
87
88 // Returns the URL of the release note for the given position
89 rtl::OUString getReleaseNote(const UpdateInfo& rInfo, sal_uInt8 pos, bool autoDownloadEnabled)
90 {
91 std::vector< ReleaseNote >::const_iterator iter = rInfo.ReleaseNotes.begin();
92 while( iter != rInfo.ReleaseNotes.end() )
93 {
94 if( pos == iter->Pos )
95 {
96 if( (pos > 2) || !autoDownloadEnabled || iter->URL2.isEmpty() )
97 return iter->URL;
98 }
99 else if( (pos == iter->Pos2) && ((1 == iter->Pos) || (2 == iter->Pos)) && autoDownloadEnabled )
100 return iter->URL2;
101
102 ++iter;
103 }
104
105 return rtl::OUString();
106 }
107
108 //------------------------------------------------------------------------------
109
110 namespace
111 {
112
113 static inline rtl::OUString getBuildId()
114 {
115 rtl::OUString aPathVal(UNISTRING("${$BRAND_BASE_DIR/program/" SAL_CONFIGFILE("version") ":buildid}"));
116 rtl::Bootstrap::expandMacros(aPathVal);
117 return aPathVal;
118 }
119
120 //------------------------------------------------------------------------------
121 static inline rtl::OUString getBaseInstallation()
122 {
123 rtl::OUString aPathVal(UNISTRING("$BRAND_BASE_DIR"));
124 rtl::Bootstrap::expandMacros(aPathVal);
125 return aPathVal;
126 }
127
128 //------------------------------------------------------------------------------
129
130 inline bool isObsoleteUpdateInfo(const rtl::OUString& rBuildId)
131 {
132 return sal_True != rBuildId.equals(getBuildId()) && !rBuildId.isEmpty();
133 }
134
135
136 //------------------------------------------------------------------------------
137
138 rtl::OUString getImageFromFileName(const rtl::OUString& aFile)
139 {
140 #ifndef WNT
141 rtl::OUString aUnpackPath;
142 if( osl_getExecutableFile(&aUnpackPath.pData) == osl_Process_E_None )
143 {
144 sal_uInt32 lastIndex = aUnpackPath.lastIndexOf('/');
145 if ( lastIndex > 0 )
146 {
147 aUnpackPath = aUnpackPath.copy( 0, lastIndex+1 );
148 aUnpackPath += UNISTRING( "unpack_update" );
149 }
150
151 oslFileHandle hOut = NULL;
152 oslProcess hProcess = NULL;
153
154 rtl::OUString aSystemPath;
155 osl::File::getSystemPathFromFileURL(aFile, aSystemPath);
156
157 oslProcessError rc = osl_executeProcess_WithRedirectedIO(
158 aUnpackPath.pData, // [in] Image name
159 &aSystemPath.pData, 1, // [in] Arguments
160 osl_Process_WAIT | osl_Process_NORMAL, // [in] Options
161 NULL, // [in] Security
162 NULL, // [in] Working directory
163 NULL, 0, // [in] Environment variables
164 &hProcess, // [out] Process handle
165 NULL, &hOut, NULL // [out] File handles for redirected I/O
166 );
167
168 if( osl_Process_E_None == rc )
169 {
170 oslProcessInfo aInfo;
171 aInfo.Size = sizeof(oslProcessInfo);
172
173 if( osl_Process_E_None == osl_getProcessInfo(hProcess, osl_Process_EXITCODE, &aInfo) )
174 {
175 if( 0 == aInfo.Code )
176 {
177 sal_Char szBuffer[4096];
178 sal_uInt64 nBytesRead = 0;
179 const sal_uInt64 nBytesToRead = sizeof(szBuffer) - 1;
180
181 rtl::OUString aImageName;
182 while( osl_File_E_None == osl_readFile(hOut, szBuffer, nBytesToRead, &nBytesRead) )
183 {
184 sal_Char *pc = szBuffer + nBytesRead;
185 do
186 {
187 *pc = '\0'; --pc;
188 }
189 while( ('\n' == *pc) || ('\r' == *pc) );
190
191 aImageName += rtl::OUString(szBuffer, pc - szBuffer + 1, osl_getThreadTextEncoding());
192
193 if( nBytesRead < nBytesToRead )
194 break;
195 }
196
197 if( osl::FileBase::E_None == osl::FileBase::getFileURLFromSystemPath(aImageName, aImageName) )
198 return aImageName;
199 }
200 }
201
202 osl_closeFile(hOut);
203 osl_freeProcessHandle(hProcess);
204 }
205 }
206 #endif
207
208 return aFile;
209 }
210
211
212 //------------------------------------------------------------------------------
213
214 static uno::Reference< beans::XPropertySet > createMenuBarUI(
215 const uno::Reference< uno::XComponentContext >& xContext,
216 const uno::Reference< task::XJob >& xJob)
217 {
218 if( !xContext.is() )
219 throw uno::RuntimeException(
220 UNISTRING( "UpdateCheckJob: empty component context" ), uno::Reference< uno::XInterface > () );
221
222 uno::Reference< lang::XMultiComponentFactory > xServiceManager(xContext->getServiceManager());
223 if( !xServiceManager.is() )
224 throw uno::RuntimeException(
225 UNISTRING( "UpdateCheckJob: unable to obtain service manager from component context" ), uno::Reference< uno::XInterface > () );
226
227 uno::Reference< beans::XPropertySet > xMenuBarUI =
228 uno::Reference< beans::XPropertySet > (
229 xServiceManager->createInstanceWithContext( UNISTRING( "com.sun.star.setup.UpdateCheckUI" ), xContext ),
230 uno::UNO_QUERY_THROW);
231
232 xMenuBarUI->setPropertyValue( PROPERTY_CLICK_HDL, uno::makeAny( xJob ) );
233
234 return xMenuBarUI;
235 }
236
237 //------------------------------------------------------------------------------
238
239
240
241 typedef sal_Bool (* OnlineCheckFunc) ();
242
243 class UpdateCheckThread : public WorkerThread
244 {
245
246 public:
247 UpdateCheckThread( osl::Condition& rCondition,
248 const uno::Reference<uno::XComponentContext>& xContext );
249
250 virtual void SAL_CALL join();
251 virtual void SAL_CALL terminate();
252 virtual void SAL_CALL cancel();
253
254 protected:
255 virtual ~UpdateCheckThread();
256
257 virtual void SAL_CALL run();
258 virtual void SAL_CALL onTerminated();
259
260 /* Wrapper around checkForUpdates */
261 bool runCheck( bool & rbExtensionsChecked );
262
263 private:
264
265 /* Used to avoid dialup login windows (on platforms we know how to double this) */
266 inline bool hasInternetConnection() const
267 {
268 #ifdef WNT
269 return WNT_hasInternetConnection();
270 #else
271 return true;
272 #endif
273 }
274
275 /* Creates a new instance of UpdateInformationProvider and returns this instance */
276 inline uno::Reference<deployment::XUpdateInformationProvider> createProvider()
277 {
278 osl::MutexGuard aGuard(m_aMutex);
279 m_xProvider = deployment::UpdateInformationProvider::create(m_xContext);
280 return m_xProvider;
281 };
282
283 /* Returns the remembered instance of UpdateInformationProvider if any */
284 inline uno::Reference<deployment::XUpdateInformationProvider> getProvider()
285 { osl::MutexGuard aGuard(m_aMutex); return m_xProvider; };
286
287 /* Releases the remembered instance of UpdateInformationProvider if any */
288 inline void clearProvider()
289 { osl::MutexGuard aGuard(m_aMutex); m_xProvider.clear(); };
290
291 osl::Mutex m_aMutex;
292 osl::Module m_aModule;
293
294 protected:
295 osl::Condition& m_aCondition;
296
297 private:
298 const uno::Reference<uno::XComponentContext> m_xContext;
299 uno::Reference<deployment::XUpdateInformationProvider> m_xProvider;
300 };
301
302
303 class ManualUpdateCheckThread : public UpdateCheckThread
304 {
305 public:
306 ManualUpdateCheckThread( osl::Condition& rCondition, const uno::Reference<uno::XComponentContext>& xContext ) :
307 UpdateCheckThread(rCondition, xContext) {};
308
309 virtual void SAL_CALL run();
310 };
311
312
313 class MenuBarButtonJob : public ::cppu::WeakImplHelper1< task::XJob >
314 {
315 public:
316 MenuBarButtonJob(const rtl::Reference< UpdateCheck >& rUpdateCheck);
317
318 // XJob
319 virtual uno::Any SAL_CALL execute(const uno::Sequence<beans::NamedValue>&)
320 throw (lang::IllegalArgumentException, uno::Exception);
321
322 private:
323 rtl::Reference< UpdateCheck > m_aUpdateCheck;
324 };
325
326 class DownloadThread : public WorkerThread
327 {
328 public:
329 DownloadThread(
330 osl::Condition& rCondition,
331 const uno::Reference<uno::XComponentContext>& xContext,
332 const rtl::Reference< DownloadInteractionHandler >& rHandler,
333 const rtl::OUString& rURL );
334
335 virtual void SAL_CALL run();
336 virtual void SAL_CALL cancel();
337 virtual void SAL_CALL suspend();
338 virtual void SAL_CALL onTerminated();
339
340 protected:
341 ~DownloadThread();
342
343 private:
344 osl::Condition& m_aCondition;
345 const uno::Reference<uno::XComponentContext> m_xContext;
346 const rtl::OUString m_aURL;
347 Download m_aDownload;
348 };
349
350 //------------------------------------------------------------------------------
351 class ShutdownThread : public osl::Thread
352 {
353 public:
354 ShutdownThread( const uno::Reference<uno::XComponentContext>& xContext );
355
356 virtual void SAL_CALL run();
357 virtual void SAL_CALL onTerminated();
358
359 protected:
360 ~ShutdownThread();
361
362 private:
363 osl::Condition m_aCondition;
364 const uno::Reference<uno::XComponentContext> m_xContext;
365 };
366
367 //------------------------------------------------------------------------------
368
369 UpdateCheckThread::UpdateCheckThread( osl::Condition& rCondition,
370 const uno::Reference<uno::XComponentContext>& xContext ) :
371 m_aCondition(rCondition),
372 m_xContext(xContext)
373 {
374 createSuspended();
375
376 // actually run the thread
377 resume();
378 }
379
380 //------------------------------------------------------------------------------
381
382 UpdateCheckThread::~UpdateCheckThread()
383 {
384 }
385
386 //------------------------------------------------------------------------------
387
388
389 void SAL_CALL
390 UpdateCheckThread::terminate()
391 {
392 // Cancel potentially hanging http request ..
393 cancel();
394 // .. before terminating
395 osl::Thread::terminate();
396 }
397
398 //------------------------------------------------------------------------------
399
400 void SAL_CALL
401 UpdateCheckThread::join()
402 {
403 uno::Reference< deployment::XUpdateInformationProvider > xProvider(getProvider());
404
405 // do not join during an update check until #i73893# is fixed
406 if( ! xProvider.is() )
407 {
408 osl::Thread::join();
409 }
410 }
411
412 //------------------------------------------------------------------------------
413
414 void SAL_CALL
415 UpdateCheckThread::cancel()
416 {
417 uno::Reference< deployment::XUpdateInformationProvider > xProvider(getProvider());
418
419 if( xProvider.is() )
420 xProvider->cancel();
421 }
422
423 //------------------------------------------------------------------------------
424
425 bool
426 UpdateCheckThread::runCheck( bool & rbExtensionsChecked )
427 {
428 bool ret = false;
429 UpdateState eUIState = UPDATESTATE_NO_UPDATE_AVAIL;
430
431 UpdateInfo aInfo;
432 rtl::Reference< UpdateCheck > aController(UpdateCheck::get());
433
434 if( checkForUpdates(aInfo, m_xContext, aController->getInteractionHandler(), createProvider()) )
435 {
436 aController->setUpdateInfo(aInfo);
437 eUIState = aController->getUIState(aInfo);
438 ret = true;
439 }
440 else
441 aController->setCheckFailedState();
442
443 // We will only look for extension updates, when there is no 'check for office updates' dialog open
444 // and when there was no office update found
445 if ( ( eUIState != UPDATESTATE_UPDATE_AVAIL ) &&
446 ( eUIState != UPDATESTATE_UPDATE_NO_DOWNLOAD ) &&
447 !aController->isDialogShowing() &&
448 !rbExtensionsChecked )
449 {
450 bool bHasExtensionUpdates = checkForExtensionUpdates( m_xContext );
451 aController->setHasExtensionUpdates( bHasExtensionUpdates );
452 if ( bHasExtensionUpdates )
453 aController->setUIState( UPDATESTATE_EXT_UPD_AVAIL );
454 rbExtensionsChecked = true;
455 }
456
457 // joining with this thread is safe again
458 clearProvider();
459 return ret;
460 }
461
462 //------------------------------------------------------------------------------
463
464 void SAL_CALL
465 UpdateCheckThread::onTerminated()
466 {
467 delete this;
468 }
469
470 //------------------------------------------------------------------------------
471
472 void SAL_CALL
473 UpdateCheckThread::run()
474 {
475 bool bExtensionsChecked = false;
476 TimeValue systime;
477 TimeValue nExtCheckTime;
478 osl_getSystemTime( &nExtCheckTime );
479
480 osl::Condition::Result aResult = osl::Condition::result_timeout;
481 TimeValue tv = { 10, 0 };
482
483 // Initial wait to avoid doing further time consuming tasks during start-up
484 aResult = m_aCondition.wait(&tv);
485
486 try {
487
488 while( sal_True == schedule() )
489 {
490 /* Use cases:
491 * a) manual check requested from auto check thread - "last check" should not be checked (one time)
492 * a1) manual check was requested in the middle of a running auto check,
493 * condition is set
494 * a2) manual check was requested while waiting for a retry,
495 * condition is set
496 * a3) manual check was requested while waiting for time to next
497 * scheduled check elapsing, condition is set
498 * a4) manual check was requested during initial wait, condition is set
499 * b) check interval got changed, condition may be set - same sub-cases as a),
500 * but "last check" should be honored
501 * c) normal auto check mode, condition not set - "last check" should be honored
502 */
503
504 // Accessing const members without synchronization
505 rtl::Reference< UpdateCheck > aController(UpdateCheck::get());
506 rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext, *aController);
507
508 // FIXME: remember last & offset ?
509 sal_Int64 last = rModel->getLastChecked();
510 sal_Int64 offset = rModel->getCheckInterval();
511
512 rModel.clear();
513
514 // last == 0 means check immediately
515 bool checkNow = ! (last > 0);
516
517 // Reset the condition to avoid busy loops
518 if( osl::Condition::result_ok == aResult )
519 {
520 m_aCondition.reset();
521 aResult = osl::Condition::result_timeout;
522 checkNow = aController->isDialogShowing();
523 }
524
525 if( ! checkNow )
526 {
527 osl_getSystemTime(&systime);
528
529 // Go back to sleep until time has elapsed
530 sal_Int64 next = last + offset;
531 if( last + offset > systime.Seconds )
532 {
533 // This can not be > 32 Bit for now ..
534 tv.Seconds = static_cast< sal_Int32 > (next - systime.Seconds);
535 aResult = m_aCondition.wait(&tv);
536 continue;
537 }
538 }
539
540 static sal_uInt8 n = 0;
541
542 if( ! hasInternetConnection() || ! runCheck( bExtensionsChecked ) )
543 {
544 // the extension update check should be independent from the office update check
545 //
546 osl_getSystemTime( &systime );
547 if ( nExtCheckTime.Seconds + offset < systime.Seconds )
548 bExtensionsChecked = false;
549
550 // Increase next by 15, 60, .. minutes
551 static const sal_Int32 nRetryInterval[] = { 900, 3600, 14400, 86400 };
552
553 if( n < SAL_N_ELEMENTS(nRetryInterval) )
554 ++n;
555
556 tv.Seconds = nRetryInterval[n-1];
557 aResult = m_aCondition.wait(&tv);
558 }
559 else // reset retry counter
560 {
561 n = 0;
562 bExtensionsChecked = false;
563 }
564 }
565 }
566
567 catch(const uno::Exception& e) {
568 // Silently catch all errors
569 OSL_TRACE( "Caught exception: %s\n thread terminated.\n",
570 rtl::OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).getStr() );
571 }
572 }
573
574 //------------------------------------------------------------------------------
575
576 void SAL_CALL
577 ManualUpdateCheckThread::run()
578 {
579 bool bExtensionsChecked = false;
580
581 try {
582 runCheck( bExtensionsChecked );
583 m_aCondition.reset();
584 }
585 catch(const uno::Exception& e) {
586 // Silently catch all errors
587 OSL_TRACE( "Caught exception: %s\n thread terminated.\n",
588 rtl::OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).getStr() );
589 }
590 }
591
592 //------------------------------------------------------------------------------
593
594 MenuBarButtonJob::MenuBarButtonJob(const rtl::Reference< UpdateCheck >& rUpdateCheck) :
595 m_aUpdateCheck(rUpdateCheck)
596 {
597 };
598
599 //------------------------------------------------------------------------------
600
601 uno::Any SAL_CALL
602 MenuBarButtonJob::execute(const uno::Sequence<beans::NamedValue>& )
603 throw (lang::IllegalArgumentException, uno::Exception)
604 {
605 if ( m_aUpdateCheck->shouldShowExtUpdDlg() )
606 m_aUpdateCheck->showExtensionDialog();
607 else
608 m_aUpdateCheck->showDialog();
609
610 return uno::Any();
611 }
612
613 //------------------------------------------------------------------------------
614
615 DownloadThread::DownloadThread(osl::Condition& rCondition,
616 const uno::Reference<uno::XComponentContext>& xContext,
617 const rtl::Reference< DownloadInteractionHandler >& rHandler,
618 const rtl::OUString& rURL) :
619 m_aCondition(rCondition),
620 m_xContext(xContext),
621 m_aURL(rURL),
622 m_aDownload(xContext, rHandler)
623 {
624 createSuspended();
625 }
626
627 //------------------------------------------------------------------------------
628
629 DownloadThread::~DownloadThread()
630 {
631 }
632
633 //------------------------------------------------------------------------------
634
635 void SAL_CALL
636 DownloadThread::run()
637 {
638 #ifdef WNT
639 CoUninitialize();
640 CoInitialize( NULL );
641 #endif
642
643 while( schedule() )
644 {
645 rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext);
646
647 rtl::OUString aLocalFile = rModel->getLocalFileName();
648 rtl::OUString aDownloadDest = rModel->getDownloadDestination();
649
650 // release config class for now
651 rModel.clear();
652
653 static sal_uInt8 n = 0;
654 if( ! m_aDownload.start(m_aURL, aLocalFile, aDownloadDest ) )
655 {
656 // retry every 15s unless the dialog is not visible
657 TimeValue tv;
658 tv.Seconds = 15;
659
660 if( ! UpdateCheck::get()->isDialogShowing() )
661 {
662 // Increase next by 1, 5, 15, 60, .. minutes
663 static const sal_Int16 nRetryInterval[] = { 60, 300, 900, 3600 };
664
665 if( n < SAL_N_ELEMENTS(nRetryInterval) )
666 ++n;
667
668 tv.Seconds = nRetryInterval[n-1];
669 }
670 m_aCondition.wait(&tv);
671 }
672 else
673 {
674 // reset wait period after successful download
675 n=0;
676 }
677 }
678 }
679
680 //------------------------------------------------------------------------------
681
682 void SAL_CALL DownloadThread::cancel()
683 {
684 m_aDownload.stop();
685 resume();
686
687 rtl::Reference< UpdateCheck > aController(UpdateCheck::get());
688 aController->cancelDownload();
689 }
690
691 //------------------------------------------------------------------------------
692
693 void SAL_CALL DownloadThread::suspend()
694 {
695 osl::Thread::suspend();
696 m_aDownload.stop();
697 }
698
699 //------------------------------------------------------------------------------
700
701 void SAL_CALL DownloadThread::onTerminated()
702 {
703 delete this;
704 }
705
706 //------------------------------------------------------------------------------
707 ShutdownThread::ShutdownThread( const uno::Reference<uno::XComponentContext>& xContext) :
708 m_xContext( xContext )
709 {
710 create();
711 }
712
713 //------------------------------------------------------------------------------
714 ShutdownThread::~ShutdownThread()
715 {
716 }
717
718 //------------------------------------------------------------------------------
719 void SAL_CALL
720 ShutdownThread::run()
721 {
722 TimeValue tv = { 0, 250 };
723
724 m_aCondition.wait(&tv);
725
726 // Tell QuickStarter not to veto ..
727 uno::Reference< beans::XFastPropertySet > xQuickStarter(
728 UpdateCheck::createService(UNISTRING("com.sun.star.office.Quickstart"), m_xContext),
729 uno::UNO_QUERY
730 );
731
732 if (xQuickStarter.is())
733 xQuickStarter->setFastPropertyValue(0, uno::makeAny(false));
734
735 // Shutdown the office
736 uno::Reference< frame::XDesktop > xDesktop(
737 UpdateCheck::createService(UNISTRING("com.sun.star.frame.Desktop"), m_xContext),
738 uno::UNO_QUERY);
739
740 if( xDesktop.is() )
741 xDesktop->terminate();
742 }
743
744 //------------------------------------------------------------------------------
745 void SAL_CALL ShutdownThread::onTerminated()
746 {
747 delete this;
748 }
749
750 //------------------------------------------------------------------------------
751
752 } // anonymous namespace
753
754
755 //------------------------------------------------------------------------------
756
757 UpdateCheck::UpdateCheck():
758 m_eState(NOT_INITIALIZED), m_eUpdateState(UPDATESTATES_COUNT),
759 m_pThread(NULL)
760 {};
761
762 UpdateCheck::~UpdateCheck() {}
763
764 void
765 UpdateCheck::initialize(const uno::Sequence< beans::NamedValue >& rValues,
766 const uno::Reference<uno::XComponentContext>& xContext)
767 {
768 osl::MutexGuard aGuard(m_aMutex);
769
770 if( NOT_INITIALIZED == m_eState )
771 {
772 NamedValueByNameAccess aNameAccess(rValues);
773 UpdateCheckROModel aModel( aNameAccess );
774 m_xContext = xContext;
775
776 rtl::OUString aUpdateEntryVersion = aModel.getUpdateEntryVersion();
777
778 aModel.getUpdateEntry(m_aUpdateInfo);
779
780 bool obsoleteUpdateInfo = isObsoleteUpdateInfo(aUpdateEntryVersion);
781 bool bContinueDownload = false;
782 bool bDownloadAvailable = false;
783
784 m_bHasExtensionUpdate = checkForPendingUpdates( xContext );
785 m_bShowExtUpdDlg = false;
786
787 rtl::OUString aLocalFileName = aModel.getLocalFileName();
788
789 if( !aLocalFileName.isEmpty() )
790 {
791 bContinueDownload = true;
792
793 // Try to get the number of bytes already on disk
794 osl::DirectoryItem aDirectoryItem;
795 if( osl::DirectoryItem::E_None == osl::DirectoryItem::get(aLocalFileName, aDirectoryItem) )
796 {
797 osl::FileStatus aFileStatus(osl_FileStatus_Mask_FileSize);
798 if( osl::DirectoryItem::E_None == aDirectoryItem.getFileStatus(aFileStatus) )
799 {
800 sal_Int64 nDownloadSize = aModel.getDownloadSize();
801 sal_Int64 nFileSize = aFileStatus.getFileSize();
802
803 if( nDownloadSize > 0 )
804 {
805 if ( nDownloadSize <= nFileSize ) // we have already downloaded everthing
806 {
807 bContinueDownload = false;
808 bDownloadAvailable = true;
809 m_aImageName = getImageFromFileName( aLocalFileName );
810 }
811 else // Calculate initial percent value.
812 {
813 sal_Int32 nPercent = (sal_Int32) (100 * nFileSize / nDownloadSize);
814 getUpdateHandler()->setProgress( nPercent );
815 }
816 }
817 }
818 }
819
820 if ( bContinueDownload )
821 {
822 bool downloadPaused = aModel.isDownloadPaused();
823
824 enableDownload(true, downloadPaused);
825 setUIState(downloadPaused ? UPDATESTATE_DOWNLOAD_PAUSED : UPDATESTATE_DOWNLOADING);
826 }
827
828 }
829 if ( !bContinueDownload )
830 {
831 // We do this intentionally only if no download is in progress ..
832 if( obsoleteUpdateInfo )
833 {
834 // Bring-up release note for position 5 ..
835 const rtl::OUString aURL(getReleaseNote(m_aUpdateInfo, 5));
836 if( !aURL.isEmpty() )
837 showReleaseNote(aURL);
838
839 // Data is outdated, probably due to installed update
840 rtl::Reference< UpdateCheckConfig > aConfig = UpdateCheckConfig::get( xContext, *this );
841 aConfig->clearUpdateFound();
842 aConfig->clearLocalFileName();
843
844
845 m_aUpdateInfo = UpdateInfo();
846 // Remove outdated release notes
847 storeReleaseNote( 1, rtl::OUString() );
848 storeReleaseNote( 2, rtl::OUString() );
849 }
850 else
851 {
852 enableAutoCheck(aModel.isAutoCheckEnabled());
853 if ( bDownloadAvailable )
854 setUIState( UPDATESTATE_DOWNLOAD_AVAIL );
855 else
856 setUIState(getUIState(m_aUpdateInfo));
857 }
858 }
859 }
860 }
861
862 //------------------------------------------------------------------------------
863
864 void
865 UpdateCheck::cancel()
866 {
867 osl::ClearableMutexGuard aGuard(m_aMutex);
868
869 WorkerThread *pThread = m_pThread;
870 UpdateState eUIState = getUIState(m_aUpdateInfo);
871
872 aGuard.clear();
873
874 if( NULL != pThread )
875 pThread->cancel();
876
877 setUIState(eUIState);
878 }
879
880 //------------------------------------------------------------------------------
881
882 void
883 UpdateCheck::download()
884 {
885 osl::ClearableMutexGuard aGuard(m_aMutex);
886 UpdateInfo aInfo(m_aUpdateInfo);
887 State eState = m_eState;
888 aGuard.clear();
889
890 if( aInfo.Sources[0].IsDirect )
891 {
892 // Ignore second click of a double click
893 if( DOWNLOADING != eState )
894 {
895 shutdownThread(true);
896
897 osl::ClearableMutexGuard aGuard2(m_aMutex);
898 enableDownload(true);
899 aGuard2.clear();
900 setUIState(UPDATESTATE_DOWNLOADING);
901 }
902 }
903 else
904 {
905 showReleaseNote(aInfo.Sources[0].URL); // Display in browser
906 }
907 }
908
909 //------------------------------------------------------------------------------
910
911 void
912 UpdateCheck::install()
913 {
914 osl::MutexGuard aGuard(m_aMutex);
915
916 const uno::Reference< c3s::XSystemShellExecute > xShellExecute(
917 createService( UNISTRING( "com.sun.star.system.SystemShellExecute" ), m_xContext ),
918 uno::UNO_QUERY );
919
920 try {
921 // Construct install command ??
922
923 // Store release note for position 3 and 4
924 rtl::OUString aURL(getReleaseNote(m_aUpdateInfo, 3));
925 storeReleaseNote(1, aURL);
926
927 aURL = getReleaseNote(m_aUpdateInfo, 4);
928 storeReleaseNote(2, aURL);
929
930 if( xShellExecute.is() )
931 {
932 rtl::OUString aInstallImage(m_aImageName);
933 osl::FileBase::getSystemPathFromFileURL(aInstallImage, aInstallImage);
934
935 rtl::OUString aParameter;
936 sal_Int32 nFlags = c3s::SystemShellExecuteFlags::DEFAULTS;
937 #if ( defined LINUX || defined SOLARIS )
938 nFlags = 42;
939 aParameter = getBaseInstallation();
940 if( !aParameter.isEmpty() )
941 osl::FileBase::getSystemPathFromFileURL(aParameter, aParameter);
942
943 aParameter += UNISTRING(" &");
944 #endif
945
946 rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get( m_xContext );
947 rModel->clearLocalFileName();
948
949 xShellExecute->execute(aInstallImage, aParameter, nFlags);
950 ShutdownThread *pShutdownThread = new ShutdownThread( m_xContext );
951 (void) pShutdownThread;
952 }
953 } catch(const uno::Exception&) {
954 m_aUpdateHandler->setErrorMessage( m_aUpdateHandler->getDefaultInstErrMsg() );
955 }
956 }
957
958 //------------------------------------------------------------------------------
959
960 void
961 UpdateCheck::pause()
962 {
963 osl::ClearableMutexGuard aGuard(m_aMutex);
964
965 if( NULL != m_pThread )
966 m_pThread->suspend();
967
968 rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext);
969 aGuard.clear();
970
971 rModel->storeDownloadPaused(true);
972 setUIState(UPDATESTATE_DOWNLOAD_PAUSED);
973 }
974
975 //------------------------------------------------------------------------------
976
977 void
978 UpdateCheck::resume()
979 {
980 osl::ClearableMutexGuard aGuard(m_aMutex);
981
982 if( NULL != m_pThread )
983 m_pThread->resume();
984
985 rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext);
986 aGuard.clear();
987
988 rModel->storeDownloadPaused(false);
989 setUIState(UPDATESTATE_DOWNLOADING);
990 }
991
992 //------------------------------------------------------------------------------
993
994 void
995 UpdateCheck::closeAfterFailure()
996 {
997 osl::ClearableMutexGuard aGuard(m_aMutex);
998
999 if ( ( m_eState == DISABLED ) || ( m_eState == CHECK_SCHEDULED ) )
1000 {
1001 const UpdateState eUIState = getUIState( m_aUpdateInfo );
1002 aGuard.clear();
1003 setUIState( eUIState, true );
1004 }
1005 }
1006
1007 //------------------------------------------------------------------------------
1008
1009 void
1010 UpdateCheck::shutdownThread(bool join)
1011 {
1012 osl::ClearableMutexGuard aGuard(m_aMutex);
1013
1014 // copy thread object pointer to stack
1015 osl::Thread *pThread = m_pThread;
1016 m_pThread = NULL;
1017 aGuard.clear();
1018
1019 if( NULL != pThread )
1020 {
1021 pThread->terminate();
1022 if( join )
1023 {
1024 m_aCondition.set();
1025 pThread->join();
1026 m_aCondition.reset();
1027 }
1028 }
1029 }
1030
1031 //------------------------------------------------------------------------------
1032
1033 void
1034 UpdateCheck::enableAutoCheck(bool enable)
1035 {
1036 if( enable )
1037 m_pThread = new UpdateCheckThread(m_aCondition, m_xContext);
1038
1039 m_eState = enable ? CHECK_SCHEDULED : DISABLED;
1040 }
1041
1042 //------------------------------------------------------------------------------
1043
1044 void
1045 UpdateCheck::enableDownload(bool enable, bool paused)
1046 {
1047 OSL_ASSERT(NULL == m_pThread);
1048
1049 State eState = DISABLED;
1050 if( enable )
1051 {
1052 m_pThread = new DownloadThread(m_aCondition, m_xContext, this, m_aUpdateInfo.Sources[0].URL );
1053 if( !paused )
1054 {
1055 eState = DOWNLOADING;
1056 m_pThread->resume();
1057 }
1058 else
1059 eState = DOWNLOAD_PAUSED;
1060
1061 m_eState = eState;
1062 }
1063 else {
1064 enableAutoCheck(UpdateCheckConfig::get(m_xContext)->isAutoCheckEnabled());
1065 }
1066
1067 }
1068
1069 //------------------------------------------------------------------------------
1070
1071 bool
1072 UpdateCheck::downloadTargetExists(const rtl::OUString& rFileName)
1073 {
1074 osl::ClearableMutexGuard aGuard(m_aMutex);
1075
1076 rtl::Reference< UpdateHandler > aUpdateHandler(getUpdateHandler());
1077 UpdateState eUIState = UPDATESTATE_DOWNLOADING;
1078
1079 bool cont = false;
1080
1081 if( aUpdateHandler->isVisible() )
1082 {
1083 cont = aUpdateHandler->showOverwriteWarning();
1084 if( cont )
1085 {
1086 if( osl_File_E_None != osl_removeFile(rFileName.pData) )
1087 {
1088 // FIXME: error message
1089 cont = false;
1090 }
1091 }
1092 else
1093 eUIState = getUIState(m_aUpdateInfo);
1094 }
1095 else
1096 {
1097 m_aImageName = getImageFromFileName(rFileName);
1098 eUIState = UPDATESTATE_DOWNLOAD_AVAIL;
1099 }
1100
1101 if( !cont )
1102 {
1103 shutdownThread(false);
1104 enableDownload(false);
1105
1106 aGuard.clear();
1107 setUIState(eUIState);
1108 }
1109
1110 return cont;
1111 }
1112
1113 //------------------------------------------------------------------------------
1114 bool UpdateCheck::checkDownloadDestination( const rtl::OUString& rFileName )
1115 {
1116 osl::ClearableMutexGuard aGuard(m_aMutex);
1117
1118 rtl::Reference< UpdateHandler > aUpdateHandler( getUpdateHandler() );
1119
1120 bool bReload = false;
1121
1122 if( aUpdateHandler->isVisible() )
1123 {
1124 bReload = aUpdateHandler->showOverwriteWarning( rFileName );
1125 }
1126
1127 return bReload;
1128 }
1129
1130 //------------------------------------------------------------------------------
1131
1132 void
1133 UpdateCheck::downloadStalled(const rtl::OUString& rErrorMessage)
1134 {
1135 osl::ClearableMutexGuard aGuard(m_aMutex);
1136 rtl::Reference< UpdateHandler > aUpdateHandler(getUpdateHandler());
1137 aGuard.clear();
1138
1139 aUpdateHandler->setErrorMessage(rErrorMessage);
1140 setUIState(UPDATESTATE_ERROR_DOWNLOADING);
1141 }
1142
1143 //------------------------------------------------------------------------------
1144
1145 void
1146 UpdateCheck::downloadProgressAt(sal_Int8 nPercent)
1147 {
1148 osl::ClearableMutexGuard aGuard(m_aMutex);
1149 rtl::Reference< UpdateHandler > aUpdateHandler(getUpdateHandler());
1150 aGuard.clear();
1151
1152 aUpdateHandler->setProgress(nPercent);
1153 setUIState(UPDATESTATE_DOWNLOADING);
1154 }
1155
1156 //------------------------------------------------------------------------------
1157
1158 void
1159 UpdateCheck::downloadStarted(const rtl::OUString& rLocalFileName, sal_Int64 nFileSize)
1160 {
1161 if ( nFileSize > 0 )
1162 {
1163 osl::MutexGuard aGuard(m_aMutex);
1164
1165 rtl::Reference< UpdateCheckConfig > aModel(UpdateCheckConfig::get(m_xContext));
1166 aModel->storeLocalFileName(rLocalFileName, nFileSize);
1167
1168 // Bring-up release note for position 1 ..
1169 const rtl::OUString aURL(getReleaseNote(m_aUpdateInfo, 1, aModel->isAutoDownloadEnabled()));
1170 if( !aURL.isEmpty() )
1171 showReleaseNote(aURL);
1172 }
1173 }
1174
1175 //------------------------------------------------------------------------------
1176
1177 void
1178 UpdateCheck::downloadFinished(const rtl::OUString& rLocalFileName)
1179 {
1180 osl::ClearableMutexGuard aGuard(m_aMutex);
1181
1182 // no more retries
1183 m_pThread->terminate();
1184
1185 m_aImageName = getImageFromFileName(rLocalFileName);
1186 UpdateInfo aUpdateInfo(m_aUpdateInfo);
1187
1188 aGuard.clear();
1189 setUIState(UPDATESTATE_DOWNLOAD_AVAIL);
1190
1191 // Bring-up release note for position 2 ..
1192 rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get( m_xContext );
1193 const rtl::OUString aURL(getReleaseNote(aUpdateInfo, 2, rModel->isAutoDownloadEnabled()));
1194 if( !aURL.isEmpty() )
1195 showReleaseNote(aURL);
1196 }
1197
1198 //------------------------------------------------------------------------------
1199
1200 void
1201 UpdateCheck::cancelDownload()
1202 {
1203 shutdownThread(true);
1204
1205 osl::MutexGuard aGuard(m_aMutex);
1206 enableDownload(false);
1207
1208 rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext);
1209
1210 rtl::OUString aLocalFile(rModel->getLocalFileName());
1211 rModel->clearLocalFileName();
1212 rModel->storeDownloadPaused(false);
1213
1214 if( isObsoleteUpdateInfo(rModel->getUpdateEntryVersion()) )
1215 {
1216 rModel->clearUpdateFound(); // This wasn't done during init yet ..
1217 m_aUpdateInfo = UpdateInfo();
1218 }
1219
1220 /*oslFileError rc =*/ osl_removeFile(aLocalFile.pData);
1221 // FIXME: error handling ..
1222
1223 }
1224
1225 //------------------------------------------------------------------------------
1226
1227 void
1228 UpdateCheck::showDialog(bool forceCheck)
1229 {
1230 osl::ResettableMutexGuard aGuard(m_aMutex);
1231
1232 bool update_found = !m_aUpdateInfo.BuildId.isEmpty();
1233 bool bSetUIState = ! m_aUpdateHandler.is();
1234
1235 UpdateState eDialogState = UPDATESTATES_COUNT;
1236
1237 switch( m_eState )
1238 {
1239 case DISABLED:
1240 case CHECK_SCHEDULED:
1241 if( forceCheck || ! update_found ) // Run check when forced or if we did not find an update yet
1242 {
1243 eDialogState = UPDATESTATE_CHECKING;
1244 bSetUIState = true;
1245 }
1246 else if(m_aUpdateInfo.Sources[0].IsDirect)
1247 eDialogState = UPDATESTATE_UPDATE_AVAIL;
1248 else
1249 eDialogState = UPDATESTATE_UPDATE_NO_DOWNLOAD;
1250 break;
1251
1252 case DOWNLOADING:
1253 eDialogState = UPDATESTATE_DOWNLOADING;
1254 break;
1255
1256 case DOWNLOAD_PAUSED:
1257 eDialogState = UPDATESTATE_DOWNLOAD_PAUSED;
1258 break;
1259
1260 case NOT_INITIALIZED:
1261 OSL_ASSERT( false );
1262 break;
1263 }
1264
1265 if( bSetUIState )
1266 {
1267 aGuard.clear();
1268 setUIState(eDialogState, true); // suppress bubble as Dialog will be visible soon
1269 aGuard.reset();
1270 }
1271
1272 getUpdateHandler()->setVisible(true);
1273
1274 // Run check in separate thread ..
1275 if( UPDATESTATE_CHECKING == eDialogState )
1276 {
1277 if( DISABLED == m_eState )
1278 {
1279 // destructs itself when done, not cancellable for now ..
1280 new ManualUpdateCheckThread(m_aCondition, m_xContext);
1281 }
1282
1283 m_aCondition.set();
1284 }
1285 }
1286
1287 //------------------------------------------------------------------------------
1288
1289 void
1290 UpdateCheck::setUpdateInfo(const UpdateInfo& aInfo)
1291 {
1292 osl::ClearableMutexGuard aGuard(m_aMutex);
1293
1294 bool bSuppressBubble = (sal_True == aInfo.BuildId.equals(m_aUpdateInfo.BuildId));
1295 m_aUpdateInfo = aInfo;
1296
1297 OSL_ASSERT(DISABLED == m_eState || CHECK_SCHEDULED == m_eState);
1298
1299 // Ignore leading non direct download if we get direct ones
1300 std::vector< DownloadSource >::iterator iter = m_aUpdateInfo.Sources.begin();
1301 while( iter != m_aUpdateInfo.Sources.end() )
1302 {
1303 if( iter->IsDirect )
1304 break;
1305
1306 ++iter;
1307 }
1308
1309 if( (iter != m_aUpdateInfo.Sources.begin()) &&
1310 (iter != m_aUpdateInfo.Sources.end()) &&
1311 iter->IsDirect )
1312 {
1313 m_aUpdateInfo.Sources.erase(m_aUpdateInfo.Sources.begin(), --iter);
1314 }
1315
1316 rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext, *this);
1317 OSL_ASSERT( rModel.is() );
1318
1319 // Decide whether to use alternate release note pos ..
1320 bool autoDownloadEnabled = rModel->isAutoDownloadEnabled();
1321
1322 std::vector< ReleaseNote >::iterator iter2 = m_aUpdateInfo.ReleaseNotes.begin();
1323 while( iter2 != m_aUpdateInfo.ReleaseNotes.end() )
1324 {
1325 if( ((1 == iter2->Pos) || (2 == iter2->Pos)) && autoDownloadEnabled && !iter2->URL2.isEmpty())
1326 {
1327 iter2->URL = iter2->URL2;
1328 iter2->URL2 = rtl::OUString();
1329 iter2->Pos = iter2->Pos2;
1330 iter2->Pos2 = 0;
1331 }
1332
1333 ++iter2;
1334 }
1335
1336 // do not move below store/clear ..
1337 rModel->updateLastChecked();
1338
1339 UpdateState eUIState;
1340 if( !m_aUpdateInfo.Sources.empty() )
1341 {
1342 rModel->storeUpdateFound(aInfo, getBuildId());
1343
1344 if( m_aUpdateInfo.Sources[0].IsDirect )
1345 {
1346 eUIState = UPDATESTATE_UPDATE_AVAIL;
1347
1348 if( rModel->isAutoDownloadEnabled() )
1349 {
1350 shutdownThread(false);
1351 eUIState = UPDATESTATE_DOWNLOADING;
1352 enableDownload(true);
1353 }
1354 }
1355 else
1356 eUIState = UPDATESTATE_UPDATE_NO_DOWNLOAD;
1357 }
1358 else
1359 {
1360 eUIState = UPDATESTATE_NO_UPDATE_AVAIL;
1361 rModel->clearUpdateFound();
1362 }
1363
1364 aGuard.clear();
1365 setUIState(eUIState, bSuppressBubble);
1366 }
1367
1368 //------------------------------------------------------------------------------
1369
1370 void
1371 UpdateCheck::setCheckFailedState()
1372 {
1373 setUIState(UPDATESTATE_ERROR_CHECKING);
1374 }
1375
1376 //------------------------------------------------------------------------------
1377 void UpdateCheck::handleMenuBarUI( rtl::Reference< UpdateHandler > rUpdateHandler,
1378 UpdateState& eState,
1379 bool suppressBubble )
1380 {
1381 uno::Reference<beans::XPropertySet> xMenuBarUI( m_xMenuBarUI );
1382
1383 if ( ( UPDATESTATE_NO_UPDATE_AVAIL == eState ) && m_bHasExtensionUpdate )
1384 eState = UPDATESTATE_EXT_UPD_AVAIL;
1385
1386 if ( UPDATESTATE_EXT_UPD_AVAIL == eState )
1387 m_bShowExtUpdDlg = true;
1388 else
1389 m_bShowExtUpdDlg = false;
1390
1391 if( xMenuBarUI.is() )
1392 {
1393 if( UPDATESTATE_NO_UPDATE_AVAIL == eState )
1394 {
1395 xMenuBarUI->setPropertyValue( PROPERTY_SHOW_MENUICON, uno::makeAny(sal_False) );
1396 }
1397 else
1398 {
1399 xMenuBarUI->setPropertyValue( PROPERTY_TITLE, uno::makeAny(rUpdateHandler->getBubbleTitle(eState)) );
1400 xMenuBarUI->setPropertyValue( PROPERTY_TEXT, uno::makeAny(rUpdateHandler->getBubbleText(eState)) );
1401
1402 if( ! suppressBubble && ( ! rUpdateHandler->isVisible() || rUpdateHandler->isMinimized() ) )
1403 xMenuBarUI->setPropertyValue( PROPERTY_SHOW_BUBBLE, uno::makeAny( sal_True ) );
1404
1405 if( UPDATESTATE_CHECKING != eState )
1406 xMenuBarUI->setPropertyValue( PROPERTY_SHOW_MENUICON, uno::makeAny(sal_True) );
1407 }
1408 }
1409 }
1410
1411 //------------------------------------------------------------------------------
1412 void UpdateCheck::setUIState(UpdateState eState, bool suppressBubble)
1413 {
1414 osl::ClearableMutexGuard aGuard(m_aMutex);
1415
1416 if( ! m_xMenuBarUI.is() &&
1417 (DISABLED != m_eState) &&
1418 ( m_bHasExtensionUpdate || (UPDATESTATE_NO_UPDATE_AVAIL != eState)) &&
1419 (UPDATESTATE_CHECKING != eState) &&
1420 (UPDATESTATE_ERROR_CHECKING != eState)
1421 )
1422 {
1423 m_xMenuBarUI = createMenuBarUI(m_xContext, new MenuBarButtonJob(this));
1424 }
1425
1426 // Show bubble only when the status has changed
1427 if ( eState == m_eUpdateState )
1428 suppressBubble = true;
1429 else
1430 m_eUpdateState = eState;
1431
1432 rtl::Reference<UpdateHandler> aUpdateHandler(getUpdateHandler());
1433 OSL_ASSERT( aUpdateHandler.is() );
1434
1435 UpdateInfo aUpdateInfo(m_aUpdateInfo);
1436 rtl::OUString aImageName(m_aImageName);
1437
1438 aGuard.clear();
1439
1440 handleMenuBarUI( aUpdateHandler, eState, suppressBubble );
1441
1442 if( (UPDATESTATE_UPDATE_AVAIL == eState)
1443 || (UPDATESTATE_DOWNLOAD_PAUSED == eState)
1444 || (UPDATESTATE_DOWNLOADING == eState) )
1445 {
1446 uno::Reference< uno::XComponentContext > xContext(m_xContext);
1447
1448 rtl::OUString aDownloadDestination =
1449 UpdateCheckConfig::get(xContext, this)->getDownloadDestination();
1450
1451 osl_getSystemPathFromFileURL(aDownloadDestination.pData, &aDownloadDestination.pData);
1452
1453 aUpdateHandler->setDownloadPath(aDownloadDestination);
1454 }
1455 else if( UPDATESTATE_DOWNLOAD_AVAIL == eState )
1456 {
1457 aUpdateHandler->setDownloadFile(aImageName);
1458 }
1459
1460 aUpdateHandler->setDescription(aUpdateInfo.Description);
1461 aUpdateHandler->setNextVersion(aUpdateInfo.Version);
1462 aUpdateHandler->setState(eState);
1463 }
1464
1465 //------------------------------------------------------------------------------
1466
1467 UpdateState
1468 UpdateCheck::getUIState(const UpdateInfo& rInfo)
1469 {
1470 UpdateState eUIState = UPDATESTATE_NO_UPDATE_AVAIL;
1471
1472 if( !rInfo.BuildId.isEmpty() )
1473 {
1474 if( rInfo.Sources[0].IsDirect )
1475 eUIState = UPDATESTATE_UPDATE_AVAIL;
1476 else
1477 eUIState = UPDATESTATE_UPDATE_NO_DOWNLOAD;
1478 }
1479
1480 return eUIState;
1481 }
1482
1483 //------------------------------------------------------------------------------
1484
1485 void
1486 UpdateCheck::showReleaseNote(const rtl::OUString& rURL) const
1487 {
1488 const uno::Reference< c3s::XSystemShellExecute > xShellExecute(
1489 createService( UNISTRING( "com.sun.star.system.SystemShellExecute" ), m_xContext ),
1490 uno::UNO_QUERY );
1491
1492 try {
1493
1494 if( xShellExecute.is() )
1495 xShellExecute->execute(rURL, rtl::OUString(), c3s::SystemShellExecuteFlags::URIS_ONLY);
1496 } catch(const c3s::SystemShellExecuteException&) {
1497 }
1498 }
1499
1500 //------------------------------------------------------------------------------
1501
1502 bool
1503 UpdateCheck::storeReleaseNote(sal_Int8 nNum, const rtl::OUString &rURL)
1504 {
1505 osl::FileBase::RC rc;
1506 rtl::OUString aTargetDir( UpdateCheckConfig::getAllUsersDirectory() + UNISTRING( "/sun" ) );
1507
1508 rc = osl::Directory::createPath( aTargetDir );
1509
1510 rtl::OUString aFileName = UNISTRING("releasenote") +
1511 rtl::OUString::valueOf( (sal_Int32) nNum ) +
1512 UNISTRING(".url");
1513
1514 rtl::OUString aFilePath;
1515 rc = osl::FileBase::getAbsoluteFileURL( aTargetDir, aFileName, aFilePath );
1516 if ( rc != osl::FileBase::E_None ) return false;
1517
1518 rc = osl::File::remove( aFilePath );
1519
1520 // don't store empty release notes, but delete old ones
1521 if ( rURL.isEmpty() )
1522 return true;
1523
1524 osl::File aFile( aFilePath );
1525 rc = aFile.open( osl_File_OpenFlag_Write | osl_File_OpenFlag_Create );
1526
1527 if ( rc != osl::FileBase::E_None ) return false;
1528
1529 rtl::OString aLineBuf("[InternetShortcut]\r\n");
1530 sal_uInt64 nWritten = 0;
1531
1532 rtl::OUString aURL( rURL );
1533 #ifdef WNT
1534 rc = aFile.write( aLineBuf.getStr(), aLineBuf.getLength(), nWritten );
1535 if ( rc != osl::FileBase::E_None ) return false;
1536 aURL = UNISTRING("URL=") + rURL;
1537 #endif
1538 aLineBuf = rtl::OUStringToOString( aURL, RTL_TEXTENCODING_UTF8 );
1539 rc = aFile.write( aLineBuf.getStr(), aLineBuf.getLength(), nWritten );
1540 if ( rc != osl::FileBase::E_None ) return false;
1541
1542 aFile.close();
1543 return true;
1544 }
1545
1546 //------------------------------------------------------------------------------
1547 void UpdateCheck::showExtensionDialog()
1548 {
1549 rtl::OUString sServiceName = UNISTRING("com.sun.star.deployment.ui.PackageManagerDialog");
1550 rtl::OUString sArguments = UNISTRING("SHOW_UPDATE_DIALOG");
1551 uno::Reference< uno::XInterface > xService;
1552
1553 if( ! m_xContext.is() )
1554 throw uno::RuntimeException(
1555 UNISTRING( "UpdateCheck::showExtensionDialog(): empty component context" ), uno::Reference< uno::XInterface > () );
1556
1557 uno::Reference< lang::XMultiComponentFactory > xServiceManager( m_xContext->getServiceManager() );
1558 if( !xServiceManager.is() )
1559 throw uno::RuntimeException(
1560 UNISTRING( "UpdateCheck::showExtensionDialog(): unable to obtain service manager from component context" ), uno::Reference< uno::XInterface > () );
1561
1562 xService = xServiceManager->createInstanceWithContext( sServiceName, m_xContext );
1563 uno::Reference< task::XJobExecutor > xExecuteable( xService, uno::UNO_QUERY );
1564 if ( xExecuteable.is() )
1565 xExecuteable->trigger( sArguments );
1566 }
1567
1568 //------------------------------------------------------------------------------
1569
1570 rtl::Reference<UpdateHandler>
1571 UpdateCheck::getUpdateHandler()
1572 {
1573 osl::MutexGuard aGuard(m_aMutex);
1574
1575 if( ! m_aUpdateHandler.is() )
1576 m_aUpdateHandler = new UpdateHandler(m_xContext, this);
1577
1578 return m_aUpdateHandler;
1579 }
1580
1581 //------------------------------------------------------------------------------
1582
1583 uno::Reference< task::XInteractionHandler >
1584 UpdateCheck::getInteractionHandler() const
1585 {
1586 osl::MutexGuard aGuard(m_aMutex);
1587
1588 uno::Reference< task::XInteractionHandler > xHandler;
1589
1590 if( m_aUpdateHandler.is() && m_aUpdateHandler->isVisible() )
1591 xHandler = m_aUpdateHandler.get();
1592
1593 return xHandler;
1594 }
1595
1596 //------------------------------------------------------------------------------
1597
1598 uno::Reference< uno::XInterface >
1599 UpdateCheck::createService(const rtl::OUString& rServiceName,
1600 const uno::Reference<uno::XComponentContext>& xContext)
1601 {
1602 if( !xContext.is() )
1603 throw uno::RuntimeException(
1604 UNISTRING( "UpdateCheckConfig: empty component context" ),
1605 uno::Reference< uno::XInterface >() );
1606
1607 const uno::Reference< lang::XMultiComponentFactory > xServiceManager(xContext->getServiceManager());
1608
1609 if( !xServiceManager.is() )
1610 throw uno::RuntimeException(
1611 UNISTRING( "UpdateCheckConfig: unable to obtain service manager from component context" ),
1612 uno::Reference< uno::XInterface >() );
1613
1614 return xServiceManager->createInstanceWithContext(rServiceName, xContext);
1615 }
1616
1617 //------------------------------------------------------------------------------
1618
1619 bool
1620 UpdateCheck::isDialogShowing() const
1621 {
1622 osl::MutexGuard aGuard(m_aMutex);
1623 return sal_True == m_aUpdateHandler.is() && m_aUpdateHandler->isVisible();
1624 };
1625
1626 //------------------------------------------------------------------------------
1627
1628 void
1629 UpdateCheck::autoCheckStatusChanged(bool enabled)
1630 {
1631 osl::ClearableMutexGuard aGuard(m_aMutex);
1632
1633 if( (CHECK_SCHEDULED == m_eState) && !enabled )
1634 shutdownThread(false);
1635
1636 if( (DISABLED == m_eState) || (CHECK_SCHEDULED == m_eState) )
1637 {
1638 enableAutoCheck(enabled);
1639 UpdateState eState = getUIState(m_aUpdateInfo);
1640 aGuard.clear();
1641 setUIState(eState);
1642 }
1643 };
1644
1645 //------------------------------------------------------------------------------
1646
1647 void
1648 UpdateCheck::autoCheckIntervalChanged()
1649 {
1650 // just wake-up
1651 m_aCondition.set();
1652 };
1653
1654 //------------------------------------------------------------------------------
1655
1656 oslInterlockedCount SAL_CALL
1657 UpdateCheck::acquire() SAL_THROW(())
1658 {
1659 return ReferenceObject::acquire();
1660 }
1661
1662 //------------------------------------------------------------------------------
1663
1664 oslInterlockedCount SAL_CALL
1665 UpdateCheck::release() SAL_THROW(())
1666 {
1667 return ReferenceObject::release();
1668 }
1669
1670 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE