1 /*

     2 * Copyright (c) 2005-2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation of the class CUPnPAiwEngine.

    15  *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 // System

    21 #include <bautils.h>

    22 #include <AknWaitDialog.h>

    23 #include <aknnotewrappers.h>

    24 #include <StringLoader.h>

    25 #include <utf.h>

    26 

    27 // Upnp stack

    28 #include <upnpitem.h>

    29 

    30 // avcontroller api

    31 #include "upnpavcontroller.h"

    32 #include "upnpavcontrollerfactory.h"

    33 #include "upnpavrenderingsession.h"

    34 #include "upnpavsessionbase.h"

    35 #include "upnpavdevice.h"

    36 

    37 // avcontroller / avcontroller helper api

    38 #include "upnpitemresolver.h"

    39 #include "upnpitemresolverfactory.h"

    40 #include "upnpitemutility.h"

    41 #include "upnpresourceselector.h"

    42 

    43 // upnpframework internal api's

    44 #include "upnpfiletransferengine.h"     // Upnp Fw / UpnpFileTransferEngine

    45 #include "upnpcommonutils.h"            // Upnp Fw / UpnpUtilities

    46 

    47 // aiw engine internal

    48 #include <upnpaiwengineresources.rsg>   // Upnp Fw / UpnpAiwEngine

    49 #include "upnpaiwengine.h"                // Upnp Fw / UpnpAiwEngine

    50 #include "upnpaiwtimer.h"               // Upnp Fw / UpnpAiwEngine

    51 

    52 // logging

    53 _LIT( KComponentLogfile, "upnpaiwengine.log" );

    54 #include "upnplog.h"

    55 

    56 const TInt KSlash = 92;

    57 const TInt KDot = 46;

    58 

    59 // CONSTANTS

    60 _LIT( KResFileName, "\\resource\\upnpaiwengineresources.rsc" );

    61 const TInt KAiwTimerIntervalInSeconds = 1;

    62 

    63 // --------------------------------------------------------------------------

    64 // CUPnPAiwEngine::NewL

    65 // NewL.

    66 // --------------------------------------------------------------------------

    67 //

    68 EXPORT_C CUPnPAiwEngine* CUPnPAiwEngine::NewL()

    69     {

    70     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::NewL" );

    71 

    72     CUPnPAiwEngine* self = NULL;

    73 

    74     // If this is the first time we are getting the instance of this

    75     // singleton class, create the instance and store it into the

    76     // Thread Local Storage

    77     if( !Dll::Tls() )

    78         {

    79         self = new (ELeave) CUPnPAiwEngine;

    80 

    81         CleanupStack::PushL( self );

    82         self->ConstructL();

    83         CleanupStack::Pop( self );

    84 

    85         TInt err = Dll::SetTls( static_cast<TAny*>( self ) );

    86         if( err != KErrNone )

    87             {

    88             delete self;

    89             self = NULL;

    90             }

    91         else

    92             {

    93             // Initialise the user counter to zero

    94             self->InitialiseUserCounter();

    95             }

    96         }

    97     else

    98         {

    99         self = static_cast<CUPnPAiwEngine*>( Dll::Tls() );

   100         }

   101 

   102     // Increase number of users by one

   103     self->IncreaseUserCounter();

   104     return self;

   105     }

   106 

   107 // --------------------------------------------------------------------------

   108 // CUPnPAiwEngine::ReleaseInstance

   109 // Releases the instance.

   110 // --------------------------------------------------------------------------

   111 //

   112 EXPORT_C void CUPnPAiwEngine::ReleaseInstance()

   113     {

   114     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::ReleaseInstance" );

   115 

   116     CUPnPAiwEngine* instance = NULL;

   117 

   118     // Get the instance from the TLS if there is an instance

   119     if( Dll::Tls() )

   120         {

   121         instance = static_cast<CUPnPAiwEngine*>( Dll::Tls() );

   122         }

   123 

   124     // If there still were an instance in the TLS

   125     if( instance )

   126         {

   127 

   128         // Decrease the number of instance

   129         instance->DecreaseUserCounter();

   130 

   131         // If the instance count is now 0, empty the TLS

   132         if( instance->UserCounter() <= 0 )

   133             {

   134             // Empty the TLS

   135             TInt err = Dll::SetTls( NULL );

   136             if( err )

   137                 {

   138                 // ignore

   139                 }

   140 

   141             // Delete the instance

   142             delete instance;

   143             instance = NULL;

   144             }

   145         }

   146     }

   147 

   148 // --------------------------------------------------------------------------

   149 // Constructor

   150 // --------------------------------------------------------------------------

   151 //

   152 CUPnPAiwEngine::CUPnPAiwEngine()

   153     {

   154     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::CUPnPAiwEngine" );

   155 

   156     iRenderingSessionInUse = EFalse;

   157     iVideoPlay = EFalse;

   158     iFileName = NULL;

   159     iVideoPlayCancel = EFalse;

   160     iVideoPlayWait = EFalse;

   161     }

   162 

   163 // --------------------------------------------------------------------------

   164 // Destructor

   165 // --------------------------------------------------------------------------

   166 //

   167 CUPnPAiwEngine::~CUPnPAiwEngine()

   168     {

   169     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::~CUPnPAiwEngine" );

   170     // Delete resolvers

   171     // Delete for resolvers is done using temporary variables so that we can

   172     // first nullify the members and then delete the actual objects.

   173     // This is because local resolver deletion uses active scheduler loops

   174     // and therefore other asynchronous events may orrur. So we may end

   175     // up here in Cleanup again, during the resolver is being deleted.

   176     // if deletion is done the conventional way, the objects get deleted

   177     // twice, which is not what we want. :-)

   178     MUPnPItemResolver* tempResolver = iResolver;

   179     iResolver = NULL;

   180     delete tempResolver;

   181     StopTimer();

   182 

   183     // If wait note is shown, finish it

   184     if (iWaitNoteDialog)

   185         {

   186         TRAP_IGNORE( iWaitNoteDialog->ProcessFinishedL() );

   187         }

   188 

   189     if (iRenderingSession && iAVController)

   190         {

   191         TRAP_IGNORE( iAVController->StopRenderingSession(

   192                         *iRenderingSession ) );

   193         iRenderingSession = NULL;

   194         }

   195 

   196     delete iCommonUI;

   197 

   198     // Delete the UPnP AV Controller

   199     delete iAVController;

   200     delete iFileName;

   201 

   202     // Un-load resource file

   203     if (iResFileOffset)

   204         {

   205         CEikonEnv::Static()->DeleteResourceFile(iResFileOffset);

   206         iResFileOffset = 0;

   207         }

   208     }

   209 

   210 // --------------------------------------------------------------------------

   211 // CUPnPAiwEngine::ConstructL

   212 // Second phase constructor

   213 // --------------------------------------------------------------------------

   214 //

   215 void CUPnPAiwEngine::ConstructL()

   216     {

   217     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::ConstructL" );

   218 

   219     iCoeEnv = CEikonEnv::Static();

   220     RFs& fileSession = iCoeEnv->FsSession();

   221 

   222     // Load resource file

   223     TFileName rscFileName(KResFileName);

   224     TFileName dllName;

   225     Dll::FileName(dllName);

   226     TBuf<2> drive = dllName.Left(2); // Drive letter followed by ':' 

   227     rscFileName.Insert( 0, drive);

   228 

   229     // Get the exact filename of the resource file

   230     BaflUtils::NearestLanguageFile(fileSession, rscFileName);

   231 

   232     // Check if the resource file exists or not

   233     if ( !BaflUtils::FileExists(fileSession, rscFileName) )

   234         {

   235         __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, resource file does not \

   236 exist!" );

   237         User::Leave(KErrNotFound);

   238         }

   239 

   240     if (iCoeEnv)

   241         {

   242         // Read the resource file offset

   243         iResFileOffset = iCoeEnv->AddResourceFileL(rscFileName);

   244         }

   245 

   246     // Set initial state of the connection to the UPnPAVController

   247     iCommonUI = CUPnPCommonUI::NewL();

   248     iAVController = NULL;

   249     iRenderingSession = NULL;

   250     iEngineState = EUPnPEngineNotConnected;

   251     }

   252 

   253 // --------------------------------------------------------------------------

   254 // CUPnPAiwEngine::SetEngineObserver

   255 // Sets the observer instance.

   256 // --------------------------------------------------------------------------

   257 //

   258 EXPORT_C void CUPnPAiwEngine::SetEngineObserver(

   259         MUPnPAiwEngineObserver* aObserver )

   260     {

   261     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::SetEngineObserver" );

   262 

   263     if( aObserver )

   264         {

   265         iObserver = aObserver;

   266         }

   267     }

   268 

   269 // --------------------------------------------------------------------------

   270 // CUPnPAiwEngine::RemoveEngineObserver

   271 // Sets the observer instance.

   272 // --------------------------------------------------------------------------

   273 //

   274 EXPORT_C void CUPnPAiwEngine::RemoveEngineObserver()

   275     {

   276     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::RemoveEngineObserver" );

   277 

   278     iObserver = NULL;

   279     }

   280 

   281 // --------------------------------------------------------------------------

   282 // CUPnPAiwEngine::EngineState

   283 // Gets the state of the UPnP AIW Engine.

   284 // --------------------------------------------------------------------------

   285 //

   286 EXPORT_C TUPnPEngineState CUPnPAiwEngine::EngineState()

   287     {

   288     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::EngineState" );

   289 

   290     return iEngineState;

   291     }

   292 

   293 // --------------------------------------------------------------------------

   294 // CUPnPAiwEngine::OpenExternalMediaL

   295 // Opens the External media UI.

   296 // --------------------------------------------------------------------------

   297 //

   298 EXPORT_C void CUPnPAiwEngine::OpenExternalMediaL()

   299     {

   300     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::OpenExternalMediaL" );

   301 

   302     TInt status = KErrNone;

   303 

   304     if( !iAVController &&

   305             iEngineState == EUPnPEngineNotConnected )

   306         {

   307         TRAP( status,

   308                 iAVController =

   309                 UPnPAVControllerFactory::NewUPnPAVControllerL() );

   310 

   311         if( status == KErrNone &&

   312                 iAVController )

   313             {

   314             // Update engine state

   315             iEngineState = EUPnPEngineBrowsingHomeNetwork;

   316             TInt leaveCode = KErrNone;

   317 

   318             TRAP( leaveCode,

   319                     status = iCommonUI->ExecuteDeviceDialogL( *iAVController ) );

   320 

   321             // Handle status and leave codes

   322             if( leaveCode != KErrNone &&

   323                     status == KErrNone )

   324                 {

   325                 status = leaveCode;

   326                 }

   327 

   328             // Clean up and return the engine state

   329             delete iAVController;

   330             iAVController = NULL;

   331             iEngineState = EUPnPEngineNotConnected;

   332             }

   333         else // If the instantiation of UpnpAvController fails

   334 

   335             {

   336             TRAP_IGNORE( ShowConnectionErrorL() );

   337             status = KErrCouldNotConnect;

   338             }

   339         }

   340     else // If the UpnpAvController is already instantiated

   341 

   342         {

   343         status = KErrInUse;

   344         }

   345 

   346     if( status != KErrNone )

   347         {

   348         User::Leave( status );

   349         }

   350     }

   351 

   352 // --------------------------------------------------------------------------

   353 // CUPnPAiwEngine::EnableExternalL

   354 // Enables the showing of local media files on a remote renderer device.

   355 // --------------------------------------------------------------------------

   356 //

   357 EXPORT_C void CUPnPAiwEngine::EnableExternalL()

   358     {

   359     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::EnableExternalL" );

   360 

   361     TInt status = KErrNone;

   362 

   363     if( !iAVController &&

   364             iEngineState == EUPnPEngineNotConnected )

   365         {

   366         TRAP( status,

   367                 iAVController =

   368                 UPnPAVControllerFactory::NewUPnPAVControllerL() );

   369 

   370         if( status == KErrNone &&

   371                 iAVController )

   372             {

   373             iAVController->SetDeviceObserver( *this );

   374             TRAP( status, StartRenderingSessionL(

   375                             EUPnPAiwEngineTargetDeviceWithImageSupport ) );

   376 

   377             // If the rendering session was created successfully

   378             if( status == KErrNone &&

   379                     iRenderingSession )

   380                 {

   381                 // Start local file sharing

   382                 TRAP( status,

   383                         StartLocalFileSharingL( iRenderingSession ) );

   384                     {

   385                     // If the file sharing failed to start, undo the enable

   386                     // external by calling disable external.

   387                     if( status != KErrNone )

   388                         {

   389                         DisableExternal();

   390                         }

   391                     }

   392                 }

   393             else

   394                 {

   395                 delete iAVController;

   396                 iAVController = NULL;

   397                 iEngineState = EUPnPEngineNotConnected;

   398                 }

   399             }

   400         else // If the instantiation of UpnpAvController fails

   401 

   402             {

   403             TRAP_IGNORE( ShowConnectionErrorL() );

   404             status = KErrCouldNotConnect;

   405             }

   406         }

   407     else

   408         {

   409         status = KErrInUse;

   410         }

   411 

   412     if( status != KErrNone )

   413         {

   414         User::Leave( status );

   415         }

   416     }

   417 

   418 // --------------------------------------------------------------------------

   419 // CUPnPAiwEngine::DisableExternal

   420 // Disables the showing of local media files on a remote renderer device.

   421 // --------------------------------------------------------------------------

   422 //

   423 EXPORT_C void CUPnPAiwEngine::DisableExternal()

   424     {

   425     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::DisableExternal" );

   426 

   427     if( iAVController )

   428         {

   429         if( iRenderingSession )

   430             {

   431             // If STOP action is required, use the timer to delay the

   432             // destruction (give some time for AvController to send the STOP

   433             // action message)

   434             if( iEngineState == EUPnPEngineActive )

   435                 {

   436                 TRAP_IGNORE( iRenderingSession->StopL() );

   437                 StartTimer();

   438                 }

   439             else

   440                 {

   441                 // Stop local file sharing

   442                 TRAP_IGNORE( iRenderingSession->ReleaseLocalMSServicesL() );

   443 

   444                 // Stop the rendering session

   445                 TRAP_IGNORE( iAVController->StopRenderingSession(

   446                                 *iRenderingSession ) );

   447                 iRenderingSession = NULL;

   448                 }

   449             }

   450 

   451         // Delete the UPnP AV Controller

   452         delete iAVController;

   453         iAVController = NULL;

   454         }

   455 

   456     // Update engine state

   457     iRenderingSessionInUse = EFalse;

   458     iEngineState = EUPnPEngineNotConnected;

   459     }

   460 

   461 // --------------------------------------------------------------------------

   462 // CUPnPAiwEngine::PlayL

   463 // Plays (sends for rendering) local media file using the selected

   464 // UPnP Media renderer.

   465 // --------------------------------------------------------------------------

   466 //

   467 EXPORT_C void CUPnPAiwEngine::PlayL( const TDesC& aFileName )

   468     {

   469     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::PlayL" );

   470 

   471     TInt status = KErrNone;

   472 

   473     if( aFileName != KNullDesC )

   474         {

   475 

   476         if( iAVController &&

   477                 iRenderingSession &&

   478                 ( iEngineState == EUPnPEngineConnected ||

   479                         iEngineState == EUPnPEngineActive ) )

   480             {

   481 

   482             // Check the file type

   483             TUPnPItemType fileType = ETypeOther;

   484             TRAPD( mimeError,

   485                     fileType = UPnPCommonUtils::ResolveFileTypeL(

   486                             aFileName ) );

   487             if( mimeError == KErrNone )

   488                 {

   489                 if( fileType == ETypeAudio )

   490                     {

   491                     status = KErrNotSupported;

   492                     if( iObserver )

   493                         {

   494                         iObserver->PlayCompleteL( status );

   495                         }

   496                     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, \

   497 audio files not supported!" );

   498                     }

   499                 else if ( fileType == ETypeVideo )

   500                     {

   501                     if( iRenderingSessionInUse )

   502                         {

   503                         //if the previous operation not finished

   504                         delete iFileName; iFileName = NULL;

   505                         iFileName = aFileName.AllocL();

   506                         iVideoPlayWait = ETrue;

   507                         }

   508                     else

   509                         {

   510                         TRAP( status, StartVideoPlayL( aFileName ) );

   511                         }

   512                     }

   513                 else if ( fileType == ETypeImage )

   514                     {

   515                     if( !iVideoPlay ) //if no video is being played

   516 

   517                         {

   518                         if( iRenderingSessionInUse )

   519                             {

   520                             //if the previous operation not finished

   521                             iVideoPlayWait = EFalse;

   522                             __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, \

   523 iRenderingSessionInUse: ETrue" );

   524                             delete iFileName;

   525                             iFileName = NULL;

   526                             iFileName = aFileName.AllocL();

   527                             }

   528                         else

   529                             {

   530                             __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, \

   531 iRenderingSessionInUse: EFalse" );

   532                             TRAP( status , CreateUpnpItemAndSetUriL( aFileName ) );

   533                             if( KErrNone == status )

   534                                 {

   535                                 iRenderingSessionInUse = ETrue;

   536                                 }

   537                             else

   538                                 {

   539                                 // Failed, notify MG, the image playing is

   540                                 // complete

   541                                 if( iObserver )

   542                                     {

   543                                     iObserver->PlayCompleteL( status );

   544                                     }

   545                                 }

   546                             }

   547                         }

   548                     else

   549                         {

   550                         //notify MG, the music playing is complete

   551                         if( iObserver )

   552                             {

   553                             iObserver->PlayCompleteL( status );

   554                             }

   555                         }

   556 

   557                     }

   558                 else // Unsupported file

   559 

   560                     {

   561                     status = KErrNotSupported;

   562                     }

   563                 }

   564             else // Failed to resolve MIME type

   565 

   566                 {

   567                 status = KErrArgument;

   568                 }

   569             }

   570         else // Rendering session not available (Enable External not done)

   571 

   572             {

   573             status = KErrNotReady;

   574             }

   575         }

   576     else

   577         {

   578         status = KErrArgument;

   579         }

   580 

   581     if( status != KErrNone )

   582         {

   583         User::Leave( status );

   584         }

   585     }

   586 

   587 // --------------------------------------------------------------------------

   588 // CUPnPAiwEngine::CopyToExternalL

   589 // Copies local files to a remote media server.

   590 // --------------------------------------------------------------------------

   591 //

   592 EXPORT_C void CUPnPAiwEngine::CopyToExternalL(

   593         RPointerArray<TDesC>& aFileNames )

   594     {

   595     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::CopyToExternalL" );

   596 

   597     // Check parameters

   598     if( aFileNames.Count() <= 0 )

   599         {

   600         User::Leave( KErrArgument );

   601         }

   602 

   603     // Check engine state

   604     if( iAVController )

   605         {

   606         User::Leave( KErrInUse );

   607         }

   608 

   609     // Create UPnPAVController

   610     TRAPD( avControllerError,

   611             iAVController = UPnPAVControllerFactory::NewUPnPAVControllerL() );

   612     if( avControllerError != KErrNone )

   613         {

   614         TRAP_IGNORE( ShowConnectionErrorL() );

   615         User::Leave( KErrCouldNotConnect );

   616         }

   617 

   618     // Update engine state

   619     iEngineState = EUPnPEngineConnected;

   620 

   621     // Do the transfer

   622     TRAPD( transferError,

   623             TransferToExternalL( EAiwEngineCopy, aFileNames, KNullDesC ) );

   624 

   625     // Clean up

   626     delete iAVController;

   627     iAVController = NULL;

   628 

   629     // Update engine state

   630     iEngineState = EUPnPEngineNotConnected;

   631 

   632     if( transferError != KErrNone )

   633         {

   634         User::Leave( transferError );

   635         }

   636     }

   637 

   638 // --------------------------------------------------------------------------

   639 // CUPnPAiwEngine::CopyToExternalL

   640 // Copies local files to a remote media server.

   641 // --------------------------------------------------------------------------

   642 //

   643 EXPORT_C void CUPnPAiwEngine::CopyPlaylistToExternalL(

   644         const TDesC& aPlaylistName,

   645         RPointerArray<TDesC>& aFileNames )

   646     {

   647     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::CopyPlaylistToExternalL" );

   648 

   649     // Check parameters

   650     if( aFileNames.Count() <= 0 ||

   651             aPlaylistName == KNullDesC )

   652         {

   653         User::Leave( KErrArgument );

   654         }

   655 

   656     // Check engine state

   657     if( iAVController )

   658         {

   659         User::Leave( KErrInUse );

   660         }

   661 

   662     // Create UPnPAVController

   663     TRAPD( avControllerError,

   664             iAVController = UPnPAVControllerFactory::NewUPnPAVControllerL() );

   665     if( avControllerError != KErrNone )

   666         {

   667         TRAP_IGNORE( ShowConnectionErrorL() );

   668         User::Leave( KErrCouldNotConnect );

   669         }

   670 

   671     // Update engine state

   672     iEngineState = EUPnPEngineConnected;

   673 

   674     // Do the transfer

   675     TRAPD( transferError,

   676             TransferToExternalL( EAiwEngineCopyPlaylist,

   677                     aFileNames,

   678                     aPlaylistName ) );

   679 

   680     // Clean up

   681     delete iAVController;

   682     iAVController = NULL;

   683 

   684     // Update engine state

   685     iEngineState = EUPnPEngineNotConnected;

   686 

   687     if( transferError != KErrNone )

   688         {

   689         User::Leave( transferError );

   690         }

   691     }

   692 

   693 // --------------------------------------------------------------------------

   694 // CUPnPAiwEngine::MoveToExternalL

   695 // Moves local files to a remote media server.

   696 // --------------------------------------------------------------------------

   697 //

   698 EXPORT_C void CUPnPAiwEngine::MoveToExternalL(

   699         RPointerArray<TDesC>& aFileNames )

   700     {

   701     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::MoveToExternalL" );

   702 

   703     // Check parameters

   704     if( aFileNames.Count() <= 0 )

   705         {

   706         User::Leave( KErrArgument );

   707         }

   708 

   709     // Check engine state

   710     if( iAVController )

   711         {

   712         User::Leave( KErrInUse );

   713         }

   714 

   715     // Create UPnPAVController

   716     TRAPD( avControllerError,

   717             iAVController = UPnPAVControllerFactory::NewUPnPAVControllerL() );

   718     if( avControllerError != KErrNone )

   719         {

   720         TRAP_IGNORE( ShowConnectionErrorL() );

   721         User::Leave( KErrCouldNotConnect );

   722         }

   723 

   724     // Update engine state

   725     iEngineState = EUPnPEngineConnected;

   726 

   727     // Do the transfer

   728     TRAPD( transferError,

   729             TransferToExternalL( EAiwEngineMove, aFileNames, KNullDesC ) );

   730 

   731     // Clean up

   732     delete iAVController;

   733     iAVController = NULL;

   734 

   735     // Update engine state

   736     iEngineState = EUPnPEngineNotConnected;

   737 

   738     if( transferError != KErrNone )

   739         {

   740         User::Leave( transferError );

   741         }

   742     }

   743 

   744 // --------------------------------------------------------------------------

   745 // CUPnPAiwEngine::TransferToExternalL

   746 // Transfers (copies/moves) local files/playlists to a remote media server.

   747 // --------------------------------------------------------------------------

   748 //

   749 void CUPnPAiwEngine::TransferToExternalL(TUPnPAiwEngineTransferMode aMode,

   750         RPointerArray<TDesC>& aFilePaths, const TDesC& aPlaylistName)

   751     {

   752     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::TransferToExternalL" );

   753 

   754     // Parameters were already checked

   755 

   756     // Select the target server device

   757     // Title should be according to ui spec.

   758     TUPnPDialogTitle title = EUPnPCopyToTitle;

   759     if (aMode == EAiwEngineMove)

   760         {

   761         title = EUPnPMoveToTitle;

   762         }

   763     CUpnpAVDevice* targetDevice = SelectDeviceL(

   764             EUPnPSearchServerDevicesWithCopyCapability, title);

   765 

   766     CleanupStack::PushL(targetDevice);

   767 

   768     // Create a browsing session

   769     TInt status = KErrNone;

   770     MUPnPAVBrowsingSession* browsingSession= NULL;

   771     TRAP( status, browsingSession =

   772             &iAVController->StartBrowsingSessionL( *targetDevice ) );

   773 

   774     if (status == KErrNone && browsingSession)

   775         {

   776         // Create a file transfer engine instance

   777         CUpnpFileTransferEngine* ftEngine= NULL;

   778         TRAP( status, 

   779                 ftEngine = CUpnpFileTransferEngine::NewL( browsingSession ) );

   780         if ( status == KErrNone && ftEngine )

   781             {

   782             CleanupStack::PushL( ftEngine );

   783 

   784             // Update engine state

   785             iEngineState = EUPnPEngineActive;

   786             

   787             // Number of files in the array.

   788             TInt count = aFilePaths.Count();

   789 

   790             // Do the copy/move

   791             if ( aMode == EAiwEngineMove )

   792                 {

   793                 TRAP( status, ftEngine->MoveLocalFilesToRemoteServerL(

   794                                 &aFilePaths ) );

   795                 }

   796             else if ( aMode == EAiwEngineCopyPlaylist)

   797                 {

   798                 TRAP( status, ftEngine->CopyLocalPlaylistToRemoteServerL(

   799                                 aPlaylistName,

   800                                 &aFilePaths ) );

   801                 }

   802             else

   803                 {

   804                 TRAP( status, ftEngine->CopyLocalFilesToRemoteServerL(

   805                                 &aFilePaths ) );

   806                 }

   807         

   808             // Clean up

   809             // aFilePaths is not updates until ftEngine is deleted!

   810             CleanupStack::PopAndDestroy( ftEngine );

   811             ftEngine = NULL;

   812             

   813             // Update engine state

   814             if ( status == KErrNone )

   815                 {

   816                 iEngineState = EUPnPEngineConnected;

   817 

   818                 // Shows proper info note.

   819                 //

   820                 // Calculate number of transferred files based on original 

   821                 // file count and items remaining in aFilePaths 

   822                 // (those were NOT transferred)

   823                 ShowTransferInfoNoteL( 

   824                         aMode, 

   825                         count - aFilePaths.Count(), 

   826                         *targetDevice );

   827                 }

   828             else if (KErrSessionClosed == status || KErrCouldNotConnect == status 

   829 			           || KErrDisconnected == status )

   830                 {

   831                 iEngineState = EUPnPEngineConnectionLost;

   832                 if ( aMode != EAiwEngineMove )

   833                     {

   834                     ShowConnectionLostCopyErrorL();

   835                     }

   836                 else

   837                     {

   838                     ShowConnectionErrorL();

   839                     }

   840                 }

   841             else if ( KErrNotFound == status )

   842                 {

   843                  ShowTransferInfoNoteL (

   844                                        aMode,

   845                                        0,

   846                                        *targetDevice );

   847                 }

   848             else

   849                 {

   850                 iEngineState = EUPnPEngineConnected;

   851                 }

   852             }

   853 

   854         // Stop browsing session

   855         iAVController->StopBrowsingSession( *browsingSession );

   856         }

   857 

   858     // Clean up

   859     CleanupStack::PopAndDestroy( targetDevice );

   860     targetDevice = NULL;

   861 

   862     // Get the titles (of the files that failed to be transfered) from

   863     // the item array and store them in the file name array. 

   864     TChar slash( KSlash );

   865     TChar dot( KDot );

   866     TInt fileCount = aFilePaths.Count();

   867     RPointerArray<TDesC16> fileTitles;

   868     for ( TInt index = 0; index < fileCount; index++ )

   869         {

   870         TInt offset1 = aFilePaths[index]->LocateReverse( slash );

   871         TInt offset2 = aFilePaths[index]->LocateReverse( dot );

   872 

   873         HBufC16* fileTitle= NULL;

   874 

   875         if ( KErrNotFound != offset1 && KErrNotFound != offset2 && 

   876              offset2 > ( offset1 + 1 ) )

   877             {

   878 

   879             fileTitle = aFilePaths[index]->

   880             Mid( ( offset1 + 1 ), ( offset2 - offset1 - 1 ) ).Alloc();

   881 

   882             }

   883         if (fileTitle)

   884             {

   885             fileTitles.AppendL(fileTitle);

   886             }

   887         }

   888     aFilePaths.ResetAndDestroy();

   889     for (TInt index = 0; index < fileTitles.Count(); index++)

   890         {

   891         aFilePaths.AppendL(fileTitles[index]);

   892         }

   893 

   894     fileTitles.Reset();

   895     fileTitles.Close();

   896 

   897     if (status != KErrNone)

   898         {

   899         User::Leave(status);

   900         }

   901     }

   902 

   903 // --------------------------------------------------------------------------

   904 // CUPnPAiwEngine::StartRenderingSessionL

   905 // Starts a rendering session with UpnpAvController. Queries the target

   906 // rendering device.

   907 // --------------------------------------------------------------------------

   908 //

   909 void CUPnPAiwEngine::StartRenderingSessionL(TUPnPAiwEngineDeviceType aType)

   910     {

   911     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::StartRenderingSessionL" );

   912 

   913     TInt status = KErrNone;

   914 

   915     if (iAVController)

   916         {

   917         if ( !iRenderingSession)

   918             {

   919             CUpnpAVDevice* tempDevice = CUpnpAVDevice::NewL();

   920             CleanupStack::PushL(tempDevice);

   921 

   922             // Launch the device selection dialog

   923 

   924             if (aType == EUPnPAiwEngineTargetDeviceWithAudioSupport)

   925                 {

   926                 status = iCommonUI->SelectDeviceL( *iAVController,

   927                         *tempDevice,

   928                         EUPnPSearchRenderingDevicesWithAudioCapability,

   929                         EUPnPSelectDeviceTitle);

   930                 }

   931             else

   932                 if (aType

   933                         == EUPnPAiwEngineTargetDeviceWithImageAndVideoSupport)

   934                     {

   935                     status = iCommonUI->SelectDeviceL( *iAVController,

   936                             *tempDevice,

   937                             EUPnPSearchRenderingDevicesWithVideoCapability,

   938                             EUPnPSelectDeviceTitle);

   939                     }

   940                 else

   941                     if (aType == EUPnPAiwEngineTargetDeviceWithImageSupport)

   942                         {

   943                         status

   944                                 = iCommonUI->SelectDeviceL(

   945                                         *iAVController,

   946                                         *tempDevice,

   947                                         EUPnPSearchRenderingDevicesWithImageCapability,

   948                                         EUPnPSelectDeviceTitle);

   949                         }

   950                     else

   951                         {

   952                         status = KErrNotSupported;

   953                         }

   954 

   955             if (status == KErrNone)

   956                 {

   957                 // Create a rendering session and register to observe the

   958                 // callbacks

   959                 __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, \

   960 creating rendering session." );

   961                 iRenderingSession

   962                         = &(iAVController->StartRenderingSessionL( *tempDevice) );

   963                 iRenderingSession->SetObserver( *this);

   964                 __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, \

   965 rendering session created." );

   966 

   967                 // Update the engine state

   968                 iEngineState = EUPnPEngineConnected;

   969                 }

   970 

   971             // Clean up

   972             CleanupStack::PopAndDestroy(tempDevice);

   973             tempDevice = NULL;

   974             }

   975         else

   976             {

   977             status = KErrInUse;

   978             }

   979         }

   980     else

   981         {

   982         status = KErrNotReady;

   983         }

   984 

   985     if (status != KErrNone)

   986         {

   987         User::Leave(status);

   988         }

   989     }

   990 

   991 // --------------------------------------------------------------------------

   992 // CUPnPAiwEngine::InteractOperationComplete

   993 // UPnP AV Controller calls this method to indicate that the requested

   994 // interaction operation (play, stop, etc.) is complete.

   995 // --------------------------------------------------------------------------

   996 //

   997 void CUPnPAiwEngine::InteractOperationComplete(TInt aError,

   998         TUPnPAVInteractOperation aOperation)

   999     {

  1000     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::InteractOperationComplete" );

  1001 

  1002     if (iObserver && !iVideoPlayCancel)

  1003         {

  1004         // If the play operation is complete (stop) or the play fails, do

  1005         // the call back

  1006         if (aOperation == EUPnPAVPlay || aOperation == EUPnPAVPlayUser

  1007                 || aOperation == EUPnPAVStop || aOperation == EUPnPAVStopUser)

  1008             {

  1009             iEngineState = EUPnPEngineConnected;

  1010             TRAP_IGNORE( iObserver->PlayCompleteL( aError ) );

  1011             }

  1012         }

  1013     if (aOperation == EUPnPAVPlay || aOperation == EUPnPAVStop)

  1014         {

  1015         iRenderingSessionInUse = EFalse;

  1016         if (iFileName) // If there is a pending item

  1017             {

  1018             __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, pending item" );

  1019             TRAP_IGNORE( InitPlayL() );

  1020             delete iFileName;

  1021             iFileName = NULL;

  1022             iVideoPlayCancel = EFalse; // No need to send StopL

  1023             }

  1024         else

  1025             {

  1026             __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, no pending item" );

  1027 

  1028             if (iVideoPlayCancel)

  1029                 {

  1030                 __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, stop previous \

  1031 video item," );

  1032                 iRenderingSessionInUse = ETrue;

  1033                 TRAP_IGNORE( iRenderingSession->StopL() );

  1034                 iVideoPlayCancel = EFalse; //StopL sent

  1035                 }

  1036             }

  1037         }

  1038     }

  1039 

  1040 // --------------------------------------------------------------------------

  1041 // CUPnPAiwEngine::SetURIResult

  1042 // UPnP AV Controller calls this method to indicate that ...

  1043 // --------------------------------------------------------------------------

  1044 //

  1045 void CUPnPAiwEngine::SetURIResult(TInt aError)

  1046     {

  1047     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::SetURIResult" );

  1048 

  1049     iRenderingSessionInUse = EFalse;

  1050     if (aError != KErrNone && iObserver && !iVideoPlayCancel)

  1051         {

  1052         TRAP_IGNORE( iObserver->PlayCompleteL( aError ) );

  1053         }

  1054     else

  1055         if ( !iRenderingSession)

  1056             {

  1057             if (iObserver)

  1058                 {

  1059                 TRAP_IGNORE( iObserver->PlayCompleteL( KErrNotReady ) );

  1060                 }

  1061             }

  1062 

  1063     if (iFileName) //if there is a pending item

  1064         {

  1065         __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, pending item" );

  1066         TRAP_IGNORE( InitPlayL() );

  1067         delete iFileName;

  1068         iFileName = NULL;

  1069         iVideoPlayCancel = EFalse; //no need to send StopL        

  1070         }

  1071     else

  1072         if ( !iVideoPlayCancel)

  1073             {

  1074             __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, no pending item" );

  1075             __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, no cancellation from \

  1076 video play" );

  1077             TRAP( aError, iRenderingSession->PlayL() );

  1078             //if play failed, send the result right way

  1079             if (aError && iObserver)

  1080                 {

  1081                 TRAP_IGNORE( iObserver->PlayCompleteL( aError ) );

  1082                 }

  1083             else

  1084                 if (KErrNone == aError)

  1085                     {

  1086                     iRenderingSessionInUse = ETrue;

  1087                     }

  1088             }

  1089         else

  1090             if (iVideoPlayCancel)

  1091                 {

  1092                 __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, no pending item" );

  1093                 __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine, stop previous \

  1094 video item" );

  1095                 TRAP_IGNORE( iRenderingSession->StopL() );

  1096                 iRenderingSessionInUse = ETrue;

  1097                 iVideoPlayCancel = EFalse; //StopL sent

  1098                 }

  1099     }

  1100 

  1101 // --------------------------------------------------------------------------

  1102 // CUPnPAiwEngine::ReleaseUpnpResourceL

  1103 // Release Upnp resouces

  1104 // --------------------------------------------------------------------------

  1105 //

  1106 void CUPnPAiwEngine::ReleaseUpnpResourceL()

  1107     {

  1108     __LOG( "[UpnpAiwEngine]\t CUPnPAiwEngine::ReleaseUpnpResourceL" );

  1109 

  1110     // Inform the client about the connection lost

  1111     if (iObserver)

  1112         {

  1113         iObserver->ConnectionLostL();

  1114         }

  1115 

  1116     // Stop the rendering session

  1117     if ( iRenderingSession && iAVController )

  1118         {

  1119         //iRenderingSession->ReleaseLocalMSServicesL();

  1120         iRenderingSession->RemoveObserver();

  1121         iAVController->StopRenderingSession( *iRenderingSession);

  1122         iRenderingSession = NULL;

  1123         }

  1124 

  1125     // Disconnect UPnPAVController

  1126     delete iAVController;

  1127     iAVController = NULL;

  1128 

  1129     iRenderingSessionInUse = EFalse;

  1130     // Update engine state

  1131     iEngineState = /*EUPnPEngineConnectionLost;*/EUPnPEngineNotConnected;

  1132     }

  1133 

  1134 // --------------------------------------------------------------------------