ucb/source/ucp/tdoc/tdoc_provider.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 /**************************************************************************
  22                                 TODO
  23  **************************************************************************
  24
  25  *************************************************************************/
  26
  27 #include "rtl/ustrbuf.hxx"
  28 #include <osl/diagnose.h>
  29
  30 #include "com/sun/star/container/XNameAccess.hpp"
  31 #include "com/sun/star/embed/XStorage.hpp"
  32
  33 #include "comphelper/processfactory.hxx"
  34 #include "ucbhelper/contentidentifier.hxx"
  35
  36 #include "tdoc_provider.hxx"
  37 #include "tdoc_content.hxx"
  38 #include "tdoc_uri.hxx"
  39 #include "tdoc_docmgr.hxx"
  40 #include "tdoc_storage.hxx"
  41
  42 using namespace com::sun::star;
  43 using namespace tdoc_ucp;
  44
  45
  46
  47
  48 // ContentProvider Implementation.
  49
  50
  51
  52
  53 ContentProvider::ContentProvider(
  54             const uno::Reference< uno::XComponentContext >& rxContext )
  55 : ::ucbhelper::ContentProviderImplHelper( rxContext ),
  56   m_xDocsMgr( new OfficeDocumentsManager( rxContext, this ) ),
  57   m_xStgElemFac( new StorageElementFactory( rxContext, m_xDocsMgr ) )
  58 {
  59 }
  60
  61
  62 // virtual
  63 ContentProvider::~ContentProvider()
  64 {
  65     if ( m_xDocsMgr.is() )
  66         m_xDocsMgr->destroy();
  67 }
  68
  69
  70
  71 // XInterface methods.
  72 void SAL_CALL ContentProvider::acquire()
  73     throw()
  74 {
  75     OWeakObject::acquire();
  76 }
  77
  78 void SAL_CALL ContentProvider::release()
  79     throw()
  80 {
  81     OWeakObject::release();
  82 }
  83
  84 css::uno::Any SAL_CALL ContentProvider::queryInterface( const css::uno::Type & rType )
  85     throw( css::uno::RuntimeException, std::exception )
  86 {
  87     css::uno::Any aRet = cppu::queryInterface( rType,
  88                                                (static_cast< lang::XTypeProvider* >(this)),
  89                                                (static_cast< lang::XServiceInfo* >(this)),
  90                                                (static_cast< ucb::XContentProvider* >(this)),
  91                                                (static_cast< frame::XTransientDocumentsDocumentContentFactory* >(this))
  92                                                );
  93     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
  94 }
  95
  96 // XTypeProvider methods.
  97
  98
  99
 100 XTYPEPROVIDER_IMPL_4( ContentProvider,
 101                       lang::XTypeProvider,
 102                       lang::XServiceInfo,
 103                       ucb::XContentProvider,
 104                       frame::XTransientDocumentsDocumentContentFactory );
 105
 106
 107
 108 // XServiceInfo methods.
 109
 110
 111
 112 XSERVICEINFO_IMPL_1_CTX(
 113     ContentProvider,
 114     OUString( "com.sun.star.comp.ucb.TransientDocumentsContentProvider" ),
 115     TDOC_CONTENT_PROVIDER_SERVICE_NAME );
 116
 117
 118
 119 // Service factory implementation.
 120
 121
 122
 123 ONE_INSTANCE_SERVICE_FACTORY_IMPL( ContentProvider );
 124
 125
 126
 127 // XContentProvider methods.
 128
 129
 130
 131 // virtual
 132 uno::Reference< ucb::XContent > SAL_CALL
 133 ContentProvider::queryContent(
 134         const uno::Reference< ucb::XContentIdentifier >& Identifier )
 135     throw( ucb::IllegalIdentifierException, uno::RuntimeException, std::exception )
 136 {
 137     Uri aUri( Identifier->getContentIdentifier() );
 138     if ( !aUri.isValid() )
 139         throw ucb::IllegalIdentifierException(
 140             OUString( "Invalid URL!" ),
 141             Identifier );
 142
 143     // Normalize URI.
 144     uno::Reference< ucb::XContentIdentifier > xCanonicId
 145         = new ::ucbhelper::ContentIdentifier( aUri.getUri() );
 146
 147     osl::MutexGuard aGuard( m_aMutex );
 148
 149     // Check, if a content with given id already exists...
 150     uno::Reference< ucb::XContent > xContent
 151         = queryExistingContent( xCanonicId ).get();
 152
 153     if ( !xContent.is() )
 154     {
 155         // Create a new content.
 156         xContent = Content::create( m_xContext, this, xCanonicId );
 157         registerNewContent( xContent );
 158     }
 159
 160     return xContent;
 161 }
 162
 163
 164
 165 // XTransientDocumentsDocumentContentFactory methods.
 166
 167
 168
 169 // virtual
 170 uno::Reference< ucb::XContent > SAL_CALL
 171 ContentProvider::createDocumentContent(
 172         const uno::Reference< frame::XModel >& Model )
 173     throw ( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
 174 {
 175     // model -> id -> content identifier -> queryContent
 176     if ( m_xDocsMgr.is() )
 177     {
 178         OUString aDocId = tdoc_ucp::OfficeDocumentsManager::queryDocumentId( Model );
 179         if ( !aDocId.isEmpty() )
 180         {
 181             OUStringBuffer aBuffer;
 182             aBuffer.appendAscii( TDOC_URL_SCHEME ":/" );
 183             aBuffer.append( aDocId );
 184
 185             uno::Reference< ucb::XContentIdentifier > xId
 186                 = new ::ucbhelper::ContentIdentifier( aBuffer.makeStringAndClear() );
 187
 188             osl::MutexGuard aGuard( m_aMutex );
 189
 190             // Check, if a content with given id already exists...
 191             uno::Reference< ucb::XContent > xContent
 192                 = queryExistingContent( xId ).get();
 193
 194             if ( !xContent.is() )
 195             {
 196                 // Create a new content.
 197                 xContent = Content::create( m_xContext, this, xId );
 198             }
 199
 200             if ( xContent.is() )
 201                 return xContent;
 202
 203             // no content.
 204             throw lang::IllegalArgumentException(
 205                 OUString(
 206                     "Illegal Content Identifier!" ),
 207                 static_cast< cppu::OWeakObject * >( this ),
 208                 1 );
 209         }
 210         else
 211         {
 212             throw lang::IllegalArgumentException(
 213                 OUString(
 214                     "Unable to obtain document id from model!" ),
 215                 static_cast< cppu::OWeakObject * >( this ),
 216                 1 );
 217         }
 218      }
 219      else
 220      {
 221         throw lang::IllegalArgumentException(
 222             OUString(
 223                 "No Document Manager!" ),
 224             static_cast< cppu::OWeakObject * >( this ),
 225             1 );
 226      }
 227 }
 228
 229
 230
 231 // interface OfficeDocumentsEventListener
 232
 233
 234
 235 // virtual
 236 void ContentProvider::notifyDocumentClosed( const OUString & rDocId )
 237 {
 238     osl::MutexGuard aGuard( getContentListMutex() );
 239
 240     ::ucbhelper::ContentRefList aAllContents;
 241     queryExistingContents( aAllContents );
 242
 243     ::ucbhelper::ContentRefList::const_iterator it  = aAllContents.begin();
 244     ::ucbhelper::ContentRefList::const_iterator end = aAllContents.end();
 245
 246     // Notify all content objects related to the closed doc.
 247
 248     bool bFoundDocumentContent = false;
 249     rtl::Reference< Content > xRoot;
 250
 251     while ( it != end )
 252     {
 253         Uri aUri( (*it)->getIdentifier()->getContentIdentifier() );
 254         OSL_ENSURE( aUri.isValid(),
 255                     "ContentProvider::notifyDocumentClosed - Invalid URI!" );
 256
 257         if ( !bFoundDocumentContent )
 258         {
 259             if ( aUri.isRoot() )
 260             {
 261                 xRoot = static_cast< Content * >( (*it).get() );
 262             }
 263             else if ( aUri.isDocument() )
 264             {
 265                 if ( aUri.getDocumentId() == rDocId )
 266                 {
 267                     bFoundDocumentContent = true;
 268
 269                     // document content will notify removal of child itself;
 270                     // no need for the root to propagate this.
 271                     xRoot.clear();
 272                 }
 273             }
 274         }
 275
 276         if ( aUri.getDocumentId() == rDocId )
 277         {
 278             // Inform content.
 279             rtl::Reference< Content > xContent
 280                 = static_cast< Content * >( (*it).get() );
 281
 282             xContent->notifyDocumentClosed();
 283         }
 284
 285         ++it;
 286     }
 287
 288     if ( xRoot.is() )
 289     {
 290         // No document content found for rDocId but root content
 291         // instantiated. Root content must announce document removal
 292         // to content event listeners.
 293         xRoot->notifyChildRemoved( rDocId );
 294     }
 295 }
 296
 297
 298 // virtual
 299 void ContentProvider::notifyDocumentOpened( const OUString & rDocId )
 300 {
 301     osl::MutexGuard aGuard( getContentListMutex() );
 302
 303     ::ucbhelper::ContentRefList aAllContents;
 304     queryExistingContents( aAllContents );
 305
 306     ::ucbhelper::ContentRefList::const_iterator it  = aAllContents.begin();
 307     ::ucbhelper::ContentRefList::const_iterator end = aAllContents.end();
 308
 309     // Find root content. If instantiated let it propagate document insertion.
 310
 311     while ( it != end )
 312     {
 313         Uri aUri( (*it)->getIdentifier()->getContentIdentifier() );
 314         OSL_ENSURE( aUri.isValid(),
 315                     "ContentProvider::notifyDocumentOpened - Invalid URI!" );
 316
 317         if ( aUri.isRoot() )
 318         {
 319             rtl::Reference< Content > xRoot
 320                 = static_cast< Content * >( (*it).get() );
 321             xRoot->notifyChildInserted( rDocId );
 322
 323             // Done.
 324             break;
 325         }
 326
 327         ++it;
 328     }
 329 }
 330
 331
 332
 333 // Non-UNO
 334
 335
 336
 337 uno::Reference< embed::XStorage >
 338 ContentProvider::queryStorage( const OUString & rUri,
 339                                StorageAccessMode eMode ) const
 340 {
 341     if ( m_xStgElemFac.is() )
 342     {
 343         try
 344         {
 345             return m_xStgElemFac->createStorage( rUri, eMode );
 346         }
 347         catch ( embed::InvalidStorageException const & )
 348         {
 349             OSL_FAIL( "Caught InvalidStorageException!" );
 350         }
 351         catch ( lang::IllegalArgumentException const & )
 352         {
 353             OSL_FAIL( "Caught IllegalArgumentException!" );
 354         }
 355         catch ( io::IOException const & )
 356         {
 357             // Okay to happen, for instance when the storage does not exist.
 358             //OSL_ENSURE( false, "Caught IOException!" );
 359         }
 360         catch ( embed::StorageWrappedTargetException const & )
 361         {
 362             OSL_FAIL( "Caught embed::StorageWrappedTargetException!" );
 363         }
 364     }
 365     return uno::Reference< embed::XStorage >();
 366 }
 367
 368
 369 uno::Reference< embed::XStorage >
 370 ContentProvider::queryStorageClone( const OUString & rUri ) const
 371 {
 372     if ( m_xStgElemFac.is() )
 373     {
 374         try
 375         {
 376             Uri aUri( rUri );
 377             uno::Reference< embed::XStorage > xParentStorage
 378                 = m_xStgElemFac->createStorage( aUri.getParentUri(), READ );
 379             uno::Reference< embed::XStorage > xStorage
 380                 = m_xStgElemFac->createTemporaryStorage();
 381
 382             xParentStorage->copyStorageElementLastCommitTo(
 383                                 aUri.getDecodedName(), xStorage );
 384             return xStorage;
 385         }
 386         catch ( embed::InvalidStorageException const & )
 387         {
 388             OSL_FAIL( "Caught InvalidStorageException!" );
 389         }
 390         catch ( lang::IllegalArgumentException const & )
 391         {
 392             OSL_FAIL( "Caught IllegalArgumentException!" );
 393         }
 394         catch ( io::IOException const & )
 395         {
 396             // Okay to happen, for instance when the storage does not exist.
 397             //OSL_ENSURE( false, "Caught IOException!" );
 398         }
 399         catch ( embed::StorageWrappedTargetException const & )
 400         {
 401             OSL_FAIL( "Caught embed::StorageWrappedTargetException!" );
 402         }
 403     }
 404
 405     return uno::Reference< embed::XStorage >();
 406 }
 407
 408
 409 uno::Reference< io::XInputStream >
 410 ContentProvider::queryInputStream( const OUString & rUri,
 411                                    const OUString & rPassword ) const
 412     throw ( packages::WrongPasswordException, css::uno::RuntimeException )
 413 {
 414     if ( m_xStgElemFac.is() )
 415     {
 416         try
 417         {
 418             return m_xStgElemFac->createInputStream( rUri, rPassword );
 419         }
 420         catch ( embed::InvalidStorageException const & )
 421         {
 422             OSL_FAIL( "Caught InvalidStorageException!" );
 423         }
 424         catch ( lang::IllegalArgumentException const & )
 425         {
 426             OSL_FAIL( "Caught IllegalArgumentException!" );
 427         }
 428         catch ( io::IOException const & )
 429         {
 430             OSL_FAIL( "Caught IOException!" );
 431         }
 432         catch ( embed::StorageWrappedTargetException const & )
 433         {
 434             OSL_FAIL( "Caught embed::StorageWrappedTargetException!" );
 435         }
 436 //        catch ( packages::WrongPasswordException const & )
 437 //        {
 438 //            // the key provided is wrong; rethrow; to be handled by caller.
 439 //            throw;
 440 //        }
 441     }
 442     return uno::Reference< io::XInputStream >();
 443 }
 444
 445
 446 uno::Reference< io::XOutputStream >
 447 ContentProvider::queryOutputStream( const OUString & rUri,
 448                                     const OUString & rPassword,
 449                                     bool bTruncate ) const
 450     throw ( packages::WrongPasswordException,
 451             uno::RuntimeException )
 452 {
 453     if ( m_xStgElemFac.is() )
 454     {
 455         try
 456         {
 457             return
 458                 m_xStgElemFac->createOutputStream( rUri, rPassword, bTruncate );
 459         }
 460         catch ( embed::InvalidStorageException const & )
 461         {
 462             OSL_FAIL( "Caught InvalidStorageException!" );
 463         }
 464         catch ( lang::IllegalArgumentException const & )
 465         {
 466             OSL_FAIL( "Caught IllegalArgumentException!" );
 467         }
 468         catch ( io::IOException const & )
 469         {
 470             // Okay to happen, for instance when the storage does not exist.
 471             //OSL_ENSURE( false, "Caught IOException!" );
 472         }
 473         catch ( embed::StorageWrappedTargetException const & )
 474         {
 475             OSL_FAIL( "Caught embed::StorageWrappedTargetException!" );
 476         }
 477 //        catch ( packages::WrongPasswordException const & )
 478 //        {
 479 //            // the key provided is wrong; rethrow; to be handled by caller.
 480 //            throw;
 481 //        }
 482     }
 483     return uno::Reference< io::XOutputStream >();
 484 }
 485
 486
 487 uno::Reference< io::XStream >
 488 ContentProvider::queryStream( const OUString & rUri,
 489                               const OUString & rPassword,
 490                               bool bTruncate ) const
 491     throw ( packages::WrongPasswordException, uno::RuntimeException )
 492 {
 493     if ( m_xStgElemFac.is() )
 494     {
 495         try
 496         {
 497             return m_xStgElemFac->createStream( rUri, rPassword, bTruncate );
 498         }
 499         catch ( embed::InvalidStorageException const & )
 500         {
 501             OSL_FAIL( "Caught InvalidStorageException!" );
 502         }
 503         catch ( lang::IllegalArgumentException const & )
 504         {
 505             OSL_FAIL( "Caught IllegalArgumentException!" );
 506         }
 507         catch ( io::IOException const & )
 508         {
 509             // Okay to happen, for instance when the storage does not exist.
 510             //OSL_ENSURE( false, "Caught IOException!" );
 511         }
 512         catch ( embed::StorageWrappedTargetException const & )
 513         {
 514             OSL_FAIL( "Caught embed::StorageWrappedTargetException!" );
 515         }
 516 //        catch ( packages::WrongPasswordException const & )
 517 //        {
 518 //            // the key provided is wrong; rethrow; to be handled by caller.
 519 //            throw;
 520 //        }
 521     }
 522     return uno::Reference< io::XStream >();
 523 }
 524
 525
 526 bool ContentProvider::queryNamesOfChildren(
 527     const OUString & rUri, uno::Sequence< OUString > & rNames ) const
 528 {
 529     Uri aUri( rUri );
 530     if ( aUri.isRoot() )
 531     {
 532         // special handling for root, which has no storage, but children.
 533         if ( m_xDocsMgr.is() )
 534         {
 535             rNames = m_xDocsMgr->queryDocuments();
 536             return true;
 537         }
 538     }
 539     else
 540     {
 541         if ( m_xStgElemFac.is() )
 542         {
 543             try
 544             {
 545                 uno::Reference< embed::XStorage > xStorage
 546                     = m_xStgElemFac->createStorage( rUri, READ );
 547
 548                 OSL_ENSURE( xStorage.is(), "Got no Storage!" );
 549
 550                 if ( xStorage.is() )
 551                 {
 552                     uno::Reference< container::XNameAccess > xNA(
 553                         xStorage, uno::UNO_QUERY );
 554
 555                     OSL_ENSURE( xNA.is(), "Got no css.container.XNameAccess!" );
 556                     if ( xNA.is() )
 557                     {
 558                         rNames = xNA->getElementNames();
 559                         return true;
 560                     }
 561                 }
 562             }
 563             catch ( embed::InvalidStorageException const & )
 564             {
 565                 OSL_FAIL( "Caught InvalidStorageException!" );
 566             }
 567             catch ( lang::IllegalArgumentException const & )
 568             {
 569                 OSL_FAIL( "Caught IllegalArgumentException!" );
 570             }
 571             catch ( io::IOException const & )
 572             {
 573                 // Okay to happen, for instance if the storage does not exist.
 574                 //OSL_ENSURE( false, "Caught IOException!" );
 575             }
 576             catch ( embed::StorageWrappedTargetException const & )
 577             {
 578                 OSL_FAIL( "Caught embed::StorageWrappedTargetException!" );
 579             }
 580         }
 581     }
 582     return false;
 583 }
 584
 585
 586 OUString
 587 ContentProvider::queryStorageTitle( const OUString & rUri ) const
 588 {
 589     OUString aTitle;
 590
 591     Uri aUri( rUri );
 592     if ( aUri.isRoot() )
 593     {
 594         // always empty.
 595         aTitle.clear();
 596     }
 597     else if ( aUri.isDocument() )
 598     {
 599         // for documents, title shall not be derived from URL. It shall
 600         // be somethimg more 'speaking' than just the document UID.
 601         if ( m_xDocsMgr.is() )
 602             aTitle = m_xDocsMgr->queryStorageTitle( aUri.getDocumentId() );
 603     }
 604     else
 605     {
 606         // derive title from URL
 607         aTitle = aUri.getDecodedName();
 608     }
 609
 610     OSL_ENSURE( !aTitle.isEmpty() || aUri.isRoot(),
 611                 "ContentProvider::queryStorageTitle - empty title!" );
 612     return aTitle;
 613 }
 614
 615
 616 uno::Reference< frame::XModel >
 617 ContentProvider::queryDocumentModel( const OUString & rUri ) const
 618 {
 619     uno::Reference< frame::XModel > xModel;
 620
 621     if ( m_xDocsMgr.is() )
 622     {
 623         Uri aUri( rUri );
 624         xModel = m_xDocsMgr->queryDocumentModel( aUri.getDocumentId() );
 625     }
 626
 627     OSL_ENSURE( xModel.is(),
 628                 "ContentProvider::queryDocumentModel - no model!" );
 629     return xModel;
 630 }
 631
 632 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */