1 /** @file

     2 * Copyright (c) 2005-2006 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:  CUpnpAVControlPoint

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "upnpavcontrolpoint.h"

    21 #include "upnpargument.h"

    22 

    23 #include "upnpstateupdatehandler.h"

    24 #include "upnpactionresponsehandler.h"

    25 #include "upnpavtactionfactory.h"

    26 #include "upnpcdsactionfactory.h"

    27 #include "upnpcmactionfactory.h"

    28 #include "upnprcactionfactory.h"

    29 #define KLogFile _L("UPnPStack.txt")

    30 #include "upnpcustomlog.h"

    31 #include "upnpcons.h"

    32 

    33 

    34 // -----------------------------------------------------------------------------

    35 // CUpnpAVControlPoint::NewL

    36 // Two-phased constructor.

    37 // -----------------------------------------------------------------------------

    38 //

    39 EXPORT_C CUpnpAVControlPoint* CUpnpAVControlPoint::NewL(

    40             MUpnpAVControlPointObserver& aAVControlPointObserver)

    41     {

    42     CUpnpAVControlPoint* self = 

    43         new (ELeave) CUpnpAVControlPoint(aAVControlPointObserver);    

    44     CleanupStack::PushL( self );

    45     self->ConstructL();

    46     CleanupStack::Pop( self );

    47     return self;

    48     }

    49 

    50 // -----------------------------------------------------------------------------

    51 // CUpnpAVControlPoint::CUpnpAVControlPoint

    52 // C++ default constructor can NOT contain any code, that

    53 // might leave.

    54 // -----------------------------------------------------------------------------

    55 //

    56 EXPORT_C CUpnpAVControlPoint::CUpnpAVControlPoint(

    57      MUpnpAVControlPointObserver& aAVControlPointObserver)

    58                 : CUpnpControlPoint(),

    59                   iAVControlPointObserver(aAVControlPointObserver)

    60     {

    61     }

    62 

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

    64 // CUpnpStateUpdateHandler::ConstructL

    65 // Symbian 2nd phase constructor can leave.

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

    67 //

    68 EXPORT_C void CUpnpAVControlPoint::ConstructL( )

    69     {

    70     _LIT8( KMediaServer, "urn:schemas-upnp-org:device:MediaServer" );

    71     _LIT8( KMediaRenderer, "urn:schemas-upnp-org:device:MediaRenderer" );

    72 

    73     CDesC8ArrayFlat* targetDeviceTypes = new(ELeave) CDesC8ArrayFlat(1);

    74     CleanupStack::PushL( targetDeviceTypes );

    75     targetDeviceTypes->AppendL( KMediaServer() );

    76     targetDeviceTypes->AppendL( KMediaRenderer() );    

    77     CUpnpControlPoint::ConstructL( *targetDeviceTypes );

    78     CleanupStack::Pop( targetDeviceTypes );

    79     targetDeviceTypes->Reset();

    80     delete targetDeviceTypes; 

    81     targetDeviceTypes = NULL;

    82 

    83     TPtrC8 devicePtr;

    84     devicePtr.Set( UpnpSSDP::KUPnPRootDevice );

    85     SearchL( devicePtr );

    86 

    87     iStateUpdateHandler = CUpnpStateUpdateHandler::NewL( 

    88         iAVControlPointObserver, 

    89         *this );

    90     iActionResponseHandler = CUpnpActionResponseHandler::NewL(

    91         iAVControlPointObserver,

    92         *this );

    93     

    94     iAvtActionFactory = CUpnpAvtActionFactory::NewL(

    95         iAVControlPointObserver,

    96         *this );

    97     iCdsActionFactory = CUpnpCdsActionFactory::NewL(

    98         iAVControlPointObserver,

    99         *this );

   100     iCmActionFactory = CUpnpCmActionFactory::NewL(

   101         iAVControlPointObserver,

   102         *this );

   103     iRcActionFactory = CUpnpRcActionFactory::NewL(

   104         iAVControlPointObserver,

   105         *this );

   106   

   107     }

   108 

   109 // -----------------------------------------------------------------------------

   110 // CUpnpAVControlPoint::~CUpnpAVControlPoint

   111 // Destructor

   112 // -----------------------------------------------------------------------------

   113 //

   114 EXPORT_C CUpnpAVControlPoint::~CUpnpAVControlPoint()

   115     {

   116     delete iStateUpdateHandler;

   117     delete iActionResponseHandler;

   118     delete iAvtActionFactory;

   119     delete iCdsActionFactory;

   120     delete iCmActionFactory;

   121     delete iRcActionFactory;

   122     }

   123 

   124 // -----------------------------------------------------------------------------

   125 // CUpnpAVControlPoint::InitializeCdsActionFactoryL

   126 // Initialize CdsActionFactory if is NULL

   127 // -----------------------------------------------------------------------------

   128 //

   129 EXPORT_C void CUpnpAVControlPoint::InitializeCdsActionFactoryL() 

   130     {

   131     

   132     if (!iCdsActionFactory)

   133         {

   134         iCdsActionFactory = CUpnpCdsActionFactory::NewL(

   135             iAVControlPointObserver,

   136             *this );

   137         }    

   138     }

   139 

   140 // -----------------------------------------------------------------------------

   141 // CUpnpAVControlPoint::StateUpdatedL

   142 // This function implements an inteface and forwards request 

   143 // to stateupdate handler.

   144 // (other items were commented in a header)

   145 // -----------------------------------------------------------------------------

   146 //

   147 EXPORT_C void CUpnpAVControlPoint::StateUpdatedL(CUpnpService*  aService)

   148     {

   149     iStateUpdateHandler->StateUpdated( aService );

   150     }

   151 

   152 // -----------------------------------------------------------------------------

   153 // CUpnpAVControlPoint::DeviceDiscoveredL

   154 // This function implements an inteface and notifies an observer.

   155 // (other items were commented in a header)

   156 // -----------------------------------------------------------------------------

   157 //

   158 EXPORT_C void CUpnpAVControlPoint::DeviceDiscoveredL(CUpnpDevice* aDevice)

   159     {

   160     iAVControlPointObserver.DeviceDiscoveredL( aDevice );

   161     }

   162 

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

   164 // CUpnpAVControlPoint::DeviceDisappearedL

   165 // This function implements an inteface and notifies an observer.

   166 // (other items were commented in a header)

   167 // -----------------------------------------------------------------------------

   168 //

   169 EXPORT_C void CUpnpAVControlPoint::DeviceDisappearedL(CUpnpDevice* aDevice)

   170     {    

   171     iAVControlPointObserver.DeviceDisappearedL(aDevice);

   172     }

   173 

   174 // -----------------------------------------------------------------------------

   175 // CUpnpAVControlPoint::ActionResponseReceivedL

   176 // This function ralizes an interface. Functionality is located in separate 

   177 // handler class.

   178 // (other items were commented in a header)

   179 // -----------------------------------------------------------------------------

   180 //

   181 EXPORT_C void CUpnpAVControlPoint::ActionResponseReceivedL(CUpnpAction* aAction)

   182     {

   183     TInt err = iActionResponseHandler->ActionResponseReceived( aAction );

   184 #ifdef _DEBUG

   185     if (err != KErrNone)

   186         {

   187         LOGS("Error in action response received.");

   188         }

   189 #endif //_DEBUG

   190     }

   191 

   192 // -----------------------------------------------------------------------------

   193 // CUpnpAVControlPoint::HttpResponseReceivedL

   194 // This function implements an inteface and notifies an observer.

   195 // (other items were commented in a header)

   196 // -----------------------------------------------------------------------------

   197 //

   198 EXPORT_C void CUpnpAVControlPoint::HttpResponseReceivedL(CUpnpHttpMessage* aMessage)

   199     {    

   200     iAVControlPointObserver.HttpResponseL( aMessage );

   201     }

   202 

   203 // -----------------------------------------------------------------------------

   204 // CUpnpAVControlPoint::Service

   205 // This function returns a pointer to appropriate service instance.

   206 // (other items were commented in a header)

   207 // -----------------------------------------------------------------------------

   208 //

   209 EXPORT_C CUpnpService* CUpnpAVControlPoint::Service( CUpnpDevice* aMediaServer, 

   210                                     const TDesC8& aServiceType )

   211     {

   212     RPointerArray<CUpnpService>& services = aMediaServer->ServiceList();

   213     

   214     for( TInt i(0); i < services.Count(); i++ )

   215         {

   216         if( services[i]->ServiceType().Match( aServiceType ) != KErrNotFound )

   217             {

   218             return services[i];

   219             }

   220         }

   221     return NULL;

   222     }

   223 

   224 // -----------------------------------------------------------------------------

   225 // CUpnpAVControlPoint::AvtSetTransportUriActionL

   226 // This function creates and sends a action.

   227 // (other items were commented in a header)

   228 // -----------------------------------------------------------------------------

   229 //

   230 EXPORT_C TInt CUpnpAVControlPoint::AvtSetTransportUriActionL(const TDesC8& aUuid,

   231                                                  TInt aInstanceId,

   232                                                  const TDesC8& aCurrentUri,

   233                                                  const TDesC8& aCurrentMetaData)

   234     {

   235     const CUpnpDevice* device = Device( aUuid );

   236     if( !device ) 

   237         {

   238         return KErrBadHandle;

   239         }

   240     else

   241         {

   242         CUpnpAction* action = NULL;

   243         TInt err( KErrNone );

   244         err = iAvtActionFactory->AvtSetTransportUriActionLC(

   245             action,

   246             (CUpnpDevice*)device,

   247             aInstanceId,

   248             aCurrentUri,

   249             aCurrentMetaData

   250             );

   251 

   252         if( err == KErrNone )

   253             {

   254             SendL( action );

   255             CleanupStack::Pop( action );

   256 

   257             return action->SessionId();

   258             }

   259         else

   260             {

   261             return err;

   262             }

   263         }

   264     }

   265 

   266 // -----------------------------------------------------------------------------

   267 // CUpnpAVControlPoint::AvtSetNextTransportUriActionL

   268 // This function creates and sends a action.

   269 // (other items were commented in a header)

   270 // -----------------------------------------------------------------------------

   271 //

   272 EXPORT_C TInt CUpnpAVControlPoint::AvtSetNextTransportUriActionL(

   273                                                  const TDesC8& aUuid,

   274                                                  TInt aInstanceId,

   275                                                  const TDesC8& aNextUri,

   276                                                  const TDesC8& aNextMetaData)

   277     {

   278     const CUpnpDevice* device = Device( aUuid );

   279     if( !device ) 

   280         {

   281         return KErrBadHandle;

   282         }

   283     else

   284         {

   285         CUpnpAction* action = NULL;

   286         TInt err( KErrNone );

   287         err = iAvtActionFactory->AvtSetNextTransportUriActionLC(

   288             action,

   289             (CUpnpDevice*)device,

   290             aInstanceId,

   291             aNextUri,

   292             aNextMetaData

   293             );

   294 

   295         if( err == KErrNone )

   296             {

   297             SendL( action );

   298             CleanupStack::Pop( action );

   299 

   300             return action->SessionId();

   301             }

   302         else

   303             {

   304             return err;

   305             }

   306         }

   307     }

   308 

   309 // -----------------------------------------------------------------------------

   310 // CUpnpAVControlPoint::AvtSeekActionL

   311 // This function creates and sends a action.

   312 // (other items were commented in a header)

   313 // -----------------------------------------------------------------------------

   314 //

   315 EXPORT_C TInt CUpnpAVControlPoint::AvtSeekActionL(const TDesC8& aUuid,

   316                                       TInt aInstanceId,

   317                                       const TDesC8& aUnit,

   318                                       const TDesC8& aTarget)

   319     {

   320     const CUpnpDevice* device = Device( aUuid );

   321     if( !device ) 

   322         {

   323         return KErrBadHandle;

   324         }

   325     else

   326         {

   327         CUpnpAction* action = NULL;

   328         TInt err( KErrNone );

   329         err = iAvtActionFactory->AvtSeekActionLC(

   330             action,

   331             (CUpnpDevice*)device,

   332             aInstanceId,

   333             aUnit,

   334             aTarget

   335             );

   336 

   337         if( err == KErrNone )

   338             {

   339             SendL( action );

   340             CleanupStack::Pop( action );

   341 

   342             return action->SessionId();

   343             }

   344         else

   345             {

   346             return err;

   347             }

   348         }

   349     }

   350 

   351 // -----------------------------------------------------------------------------

   352 // CUpnpAVControlPoint::AvtMediaInfoActionL

   353 // This function creates and sends a action.

   354 // (other items were commented in a header)

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

   356 //

   357 EXPORT_C TInt CUpnpAVControlPoint::AvtMediaInfoActionL(const TDesC8& aUuid,

   358                                            TInt aInstanceId)

   359     {

   360     const CUpnpDevice* device = Device( aUuid );

   361     if( !device ) 

   362         {

   363         return KErrBadHandle;

   364         }

   365     else

   366         {

   367         CUpnpAction* action = NULL;

   368         TInt err( KErrNone );

   369         err = iAvtActionFactory->AvtMediaInfoActionLC(

   370             action,

   371             (CUpnpDevice*)device,

   372             aInstanceId

   373             );

   374 

   375         if( err == KErrNone )

   376             {

   377             SendL( action );

   378             CleanupStack::Pop( action );

   379 

   380             return action->SessionId();

   381             }

   382         else

   383             {

   384             return err;

   385             }

   386         }

   387     }

   388 

   389 // -----------------------------------------------------------------------------

   390 // CUpnpAVControlPoint::AvtTransportInfoActionL

   391 // This function creates and sends a action.

   392 // (other items were commented in a header)

   393 // -----------------------------------------------------------------------------

   394 //

   395 EXPORT_C TInt CUpnpAVControlPoint::AvtTransportInfoActionL(const TDesC8& aUuid,

   396                                                TInt aInstanceId)

   397     {

   398     const CUpnpDevice* device = Device( aUuid );

   399     if( !device ) 

   400         {

   401         return KErrBadHandle;

   402         }

   403     else

   404         {

   405         CUpnpAction* action = NULL;

   406         TInt err( KErrNone );

   407         err = iAvtActionFactory->AvtTransportInfoActionLC(

   408             action,

   409             (CUpnpDevice*)device,

   410             aInstanceId

   411             );

   412 

   413         if( err == KErrNone )

   414             {

   415             SendL( action );

   416             CleanupStack::Pop( action );

   417 

   418             return action->SessionId();

   419             }

   420         else

   421             {

   422             return err;

   423             }

   424         }

   425     }

   426 

   427 // -----------------------------------------------------------------------------

   428 // CUpnpAVControlPoint::AvtPositionInfoActionL

   429 // This function creates and sends a action.

   430 // (other items were commented in a header)

   431 // -----------------------------------------------------------------------------

   432 //

   433 EXPORT_C TInt CUpnpAVControlPoint::AvtPositionInfoActionL(const TDesC8& aUuid,

   434                                               TInt aInstanceId)

   435     {

   436     const CUpnpDevice* device = Device( aUuid );

   437     if( !device ) 

   438         {

   439         return KErrBadHandle;

   440         }

   441     else

   442         {

   443         CUpnpAction* action = NULL;

   444         TInt err( KErrNone );

   445         err = iAvtActionFactory->AvtPositionInfoActionLC(

   446             action,

   447             (CUpnpDevice*)device,

   448             aInstanceId

   449             );

   450 

   451         if( err == KErrNone )

   452             {

   453             SendL( action );

   454             CleanupStack::Pop( action );

   455 

   456             return action->SessionId();

   457             }

   458         else

   459             {

   460             return err;

   461             }

   462         }

   463     }

   464 

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

   466 // CUpnpAVControlPoint::AvtDeviceCapabilitiesActionL

   467 // This function creates and sends a action.

   468 // (other items were commented in a header)

   469 // -----------------------------------------------------------------------------

   470 //

   471 EXPORT_C TInt CUpnpAVControlPoint::AvtDeviceCapabilitiesActionL(const TDesC8& aUuid,

   472                                                     TInt aInstanceId)

   473     {

   474     const CUpnpDevice* device = Device( aUuid );

   475     if( !device ) 

   476         {

   477         return KErrBadHandle;

   478         }

   479     else

   480         {

   481         CUpnpAction* action = NULL;

   482         TInt err( KErrNone );

   483         err = iAvtActionFactory->AvtDeviceCapabilitiesActionLC(

   484             action,

   485             (CUpnpDevice*)device,

   486             aInstanceId

   487             );

   488 

   489         if( err == KErrNone )

   490             {

   491             SendL( action );

   492             CleanupStack::Pop( action );

   493 

   494             return action->SessionId();

   495             }

   496         else

   497             {

   498             return err;

   499             }

   500         }

   501     }

   502 

   503 // -----------------------------------------------------------------------------

   504 // CUpnpAVControlPoint::AvtTransportSettingsActionL

   505 // This function creates and sends a action.

   506 // (other items were commented in a header)

   507 // -----------------------------------------------------------------------------

   508 //

   509 EXPORT_C TInt CUpnpAVControlPoint::AvtTransportSettingsActionL(const TDesC8& aUuid,

   510                                                    TInt aInstanceId)

   511     {

   512     const CUpnpDevice* device = Device( aUuid );

   513     if( !device ) 

   514         {

   515         return KErrBadHandle;

   516         }

   517     else

   518         {

   519         CUpnpAction* action = NULL;

   520         TInt err( KErrNone );

   521         err = iAvtActionFactory->AvtTransportSettingsActionLC(

   522             action,

   523             (CUpnpDevice*)device,

   524             aInstanceId

   525             );

   526 

   527         if( err == KErrNone )

   528             {

   529             SendL( action );

   530             CleanupStack::Pop( action );

   531 

   532             return action->SessionId();

   533             }

   534         else

   535             {

   536             return err;

   537             }

   538         }

   539     }

   540 

   541 // -----------------------------------------------------------------------------

   542 // CUpnpAVControlPoint::AvtStopActionL

   543 // This function creates and sends a action.

   544 // (other items were commented in a header)

   545 // -----------------------------------------------------------------------------

   546 //

   547 EXPORT_C TInt CUpnpAVControlPoint::AvtStopActionL(const TDesC8& aUuid,

   548                                       TInt aInstanceId)

   549     {

   550     const CUpnpDevice* device = Device( aUuid );

   551     if( !device ) 

   552         {

   553         return KErrBadHandle;

   554         }

   555     else

   556         {

   557         CUpnpAction* action = NULL;

   558         TInt err( KErrNone );

   559         err = iAvtActionFactory->AvtStopActionLC(

   560             action,

   561             (CUpnpDevice*)device,

   562             aInstanceId

   563             );

   564 

   565         if( err == KErrNone )

   566             {

   567             SendL( action );

   568             CleanupStack::Pop( action );

   569 

   570             return action->SessionId();

   571             }

   572         else

   573             {

   574             return err;

   575             }

   576         }

   577     }

   578 

   579 // -----------------------------------------------------------------------------

   580 // CUpnpAVControlPoint::AvtPlayActionL

   581 // This function creates and sends a action.

   582 // (other items were commented in a header)

   583 // -----------------------------------------------------------------------------

   584 //

   585 EXPORT_C TInt CUpnpAVControlPoint::AvtPlayActionL(const TDesC8& aUuid,

   586                                       TInt aInstanceId,

   587                                       const TDesC8& aSpeed)

   588     {

   589     const CUpnpDevice* device = Device( aUuid );

   590     if( !device ) 

   591         {

   592         return KErrBadHandle;

   593         }

   594     else

   595         {

   596         CUpnpAction* action = NULL;

   597         TInt err( KErrNone );

   598         err = iAvtActionFactory->AvtPlayActionLC(

   599             action,

   600             (CUpnpDevice*)device,

   601             aInstanceId,

   602             aSpeed

   603             );

   604 

   605         if( err == KErrNone )

   606             {

   607             SendL( action );

   608             CleanupStack::Pop( action );

   609 

   610             return action->SessionId();

   611             }

   612         else

   613             {

   614             return err;

   615             }

   616         }

   617     }

   618 

   619 // -----------------------------------------------------------------------------

   620 // CUpnpAVControlPoint::AvtPauseActionL

   621 // This function creates and sends a action.

   622 // (other items were commented in a header)

   623 // -----------------------------------------------------------------------------

   624 //

   625 EXPORT_C TInt CUpnpAVControlPoint::AvtPauseActionL(const TDesC8& aUuid,

   626                                        TInt aInstanceId)

   627     {

   628     const CUpnpDevice* device = Device( aUuid );

   629     if( !device ) 

   630         {

   631         return KErrBadHandle;

   632         }

   633     else

   634         {

   635         CUpnpAction* action = NULL;

   636         TInt err( KErrNone );

   637         err = iAvtActionFactory->AvtPauseActionLC(

   638             action,

   639             (CUpnpDevice*)device,

   640             aInstanceId

   641             );

   642 

   643         if( err == KErrNone )

   644             {

   645             SendL( action );

   646             CleanupStack::Pop( action );

   647 

   648             return action->SessionId();

   649             }

   650         else

   651             {

   652             return err;

   653             }

   654         }

   655     }

   656 

   657 // -----------------------------------------------------------------------------

   658 // CUpnpAVControlPoint::AvtRecordActionL

   659 // This function creates and sends a action.

   660 // (other items were commented in a header)

   661 // -----------------------------------------------------------------------------

   662 //

   663 EXPORT_C TInt CUpnpAVControlPoint::AvtRecordActionL(const TDesC8& aUuid,

   664                                         TInt aInstanceId)

   665     {

   666     const CUpnpDevice* device = Device( aUuid );

   667     if( !device ) 

   668         {

   669         return KErrBadHandle;

   670         }

   671     else

   672         {

   673         CUpnpAction* action = NULL;

   674         TInt err( KErrNone );

   675         err = iAvtActionFactory->AvtRecordActionLC(

   676             action,

   677             (CUpnpDevice*)device,

   678             aInstanceId );

   679 

   680         if( err == KErrNone )

   681             {

   682             SendL( action );

   683             CleanupStack::Pop( action );

   684 

   685             return action->SessionId();

   686             }

   687         else

   688             {

   689             return err;

   690             }

   691         }

   692     }

   693 

   694 // -----------------------------------------------------------------------------

   695 // CUpnpAVControlPoint::AvtNextActionL

   696 // This function creates and sends a action.

   697 // (other items were commented in a header)

   698 // -----------------------------------------------------------------------------

   699 //

   700 EXPORT_C TInt CUpnpAVControlPoint::AvtNextActionL(const TDesC8& aUuid,

   701                                       TInt aInstanceId)

   702     {

   703     const CUpnpDevice* device = Device( aUuid );

   704     if( !device ) 

   705         {

   706         return KErrBadHandle;

   707         }

   708     else

   709         {

   710         CUpnpAction* action = NULL;

   711         TInt err( KErrNone );

   712         err = iAvtActionFactory->AvtNextActionLC(

   713             action,

   714             (CUpnpDevice*)device,

   715             aInstanceId

   716             );

   717 

   718         if( err == KErrNone )

   719             {

   720             

   721             SendL( action );

   722             CleanupStack::Pop( action );

   723 

   724             return action->SessionId();

   725             }

   726         else

   727             {

   728             return err;

   729             }

   730         }

   731     }

   732 

   733 // -----------------------------------------------------------------------------

   734 // CUpnpAVControlPoint::AvtPreviousActionL

   735 // This function creates and sends a action.

   736 // (other items were commented in a header)

   737 // -----------------------------------------------------------------------------

   738 //

   739 EXPORT_C TInt CUpnpAVControlPoint::AvtPreviousActionL(const TDesC8& aUuid,

   740                                           TInt aInstanceId)

   741     {

   742     const CUpnpDevice* device = Device( aUuid );

   743     if( !device ) 

   744         {

   745         return KErrBadHandle;

   746         }

   747     else

   748         {

   749         CUpnpAction* action = NULL;

   750         TInt err( KErrNone );

   751         err = iAvtActionFactory->AvtPreviousActionLC(

   752             action,

   753             (CUpnpDevice*)device,

   754             aInstanceId

   755             );

   756 

   757         if( err == KErrNone )

   758             {

   759             

   760             SendL( action );

   761             CleanupStack::Pop( action );

   762 

   763             return action->SessionId();

   764             }

   765         else

   766             {

   767             return err;

   768             }

   769         }

   770     }

   771 

   772 // -----------------------------------------------------------------------------

   773 // CUpnpAVControlPoint::AvtSetPlayModeActionL

   774 // This function creates and sends a action.

   775 // (other items were commented in a header)

   776 // -----------------------------------------------------------------------------

   777 //

   778 EXPORT_C TInt CUpnpAVControlPoint::AvtSetPlayModeActionL(const TDesC8& aUuid,

   779                                              TInt aInstanceId,

   780                                              const TDesC8& aPlayMode)

   781     {

   782     const CUpnpDevice* device = Device( aUuid );

   783     if( !device ) 

   784         {

   785         return KErrBadHandle;

   786         }

   787     else

   788         {

   789         CUpnpAction* action = NULL;

   790         TInt err( KErrNone );

   791         err = iAvtActionFactory->AvtSetPlayModeActionLC(

   792             action,

   793             (CUpnpDevice*)device,

   794             aInstanceId,

   795             aPlayMode

   796             );

   797 

   798         if( err == KErrNone )

   799             {

   800             

   801             SendL( action );

   802             CleanupStack::Pop( action );

   803 

   804             return action->SessionId();

   805             }

   806         else

   807             {

   808             return err;

   809             }

   810         }

   811     }

   812 

   813 // -----------------------------------------------------------------------------

   814 // CUpnpAVControlPoint::AvtSetRecordModeActionL

   815 // This function creates and sends a action.

   816 // (other items were commented in a header)

   817 // -----------------------------------------------------------------------------

   818 //

   819 EXPORT_C TInt CUpnpAVControlPoint::AvtSetRecordModeActionL(const TDesC8& aUuid,

   820                                                TInt aInstanceId,

   821                                                const TDesC8& aRecordMode)

   822     {

   823     const CUpnpDevice* device = Device( aUuid );

   824     if( !device ) 

   825         {

   826         return KErrBadHandle;

   827         }

   828     else

   829         {

   830         CUpnpAction* action = NULL;

   831         TInt err( KErrNone );

   832         err = iAvtActionFactory->AvtSetRecordModeActionLC(

   833             action,

   834             (CUpnpDevice*)device,

   835             aInstanceId,

   836             aRecordMode

   837             );

   838 

   839         if( err == KErrNone )

   840             {

   841             

   842             SendL( action );

   843             CleanupStack::Pop( action );

   844 

   845             return action->SessionId();

   846             }

   847         else

   848             {

   849             return err;

   850             }

   851         }

   852     }

   853 

   854 // -----------------------------------------------------------------------------

   855 // CUpnpAVControlPoint::AvtTransportsActionL

   856 // This function creates and sends a action.

   857 // (other items were commented in a header)

   858 // -----------------------------------------------------------------------------

   859 //

   860 EXPORT_C TInt CUpnpAVControlPoint::AvtTransportsActionL(const TDesC8& aUuid,

   861                                             TInt aInstanceId)

   862     {

   863     const CUpnpDevice* device = Device( aUuid );

   864     if( !device ) 

   865         {

   866         return KErrBadHandle;

   867         }

   868     else

   869         {

   870         CUpnpAction* action = NULL;

   871         TInt err( KErrNone );

   872         err = iAvtActionFactory->AvtTransportsActionLC(

   873             action,

   874             (CUpnpDevice*)device,

   875             aInstanceId

   876             );

   877 

   878         if( err == KErrNone )

   879             {

   880             

   881             SendL( action );

   882             CleanupStack::Pop( action );

   883 

   884             return action->SessionId();

   885             }

   886         else

   887             {

   888             return err;

   889             }

   890         }

   891     }

   892 

   893 // -----------------------------------------------------------------------------

   894 // CUpnpAVControlPoint::CdsBrowseActionL

   895 // This function creates and sends a action.

   896 // (other items were commented in a header)

   897 // -----------------------------------------------------------------------------

   898 //

   899 EXPORT_C TInt CUpnpAVControlPoint::CdsBrowseActionL(const TDesC8& aUuid,

   900                                         const TDesC8& aObjectId,

   901                                         const TDesC8& aBrowseFlag,

   902                                         const TDesC8& aFilter, 

   903                                         TInt aStartingIndex,

   904                                         TInt aRequestedCount,

   905                                         const TDesC8& aSortCriteria)

   906     {

   907     const CUpnpDevice* device = Device( aUuid );

   908     if( !device ) 

   909         {

   910         return KErrBadHandle;

   911         }

   912     else

   913         {

   914         CUpnpAction* action = NULL;

   915         TInt err( KErrNone );

   916         err = iCdsActionFactory->CdsBrowseActionLC(

   917             action,

   918             (CUpnpDevice*)device,

   919             aObjectId,

   920             aBrowseFlag,

   921             aFilter,

   922             aStartingIndex,

   923             aRequestedCount,

   924             aSortCriteria

   925             );

   926 

   927         if( err == KErrNone )

   928             {

   929             

   930             SendL( action );

   931             CleanupStack::Pop( action );

   932 

   933             return action->SessionId();

   934             }

   935         else

   936             {

   937             return err;

   938             }

   939         }

   940     }

   941 

   942 // -----------------------------------------------------------------------------

   943 // CUpnpAVControlPoint::CdsSearchActionL

   944 // This function creates and sends a action.

   945 // (other items were commented in a header)

   946 // -----------------------------------------------------------------------------

   947 //

   948 EXPORT_C TInt CUpnpAVControlPoint::CdsSearchActionL(const TDesC8& aUuid,

   949                                         const TDesC8& aObjectId,

   950                                         const TDesC8& aSearchCriteria,

   951                                         const TDesC8& aFilter, 

   952                                         TInt aStartingIndex,

   953                                         TInt aRequestedCount,

   954                                         const TDesC8& aSortCriteria

   955                                         )

   956     {

   957     const CUpnpDevice* device = Device( aUuid );

   958     if( !device ) 

   959         {

   960         return KErrBadHandle;

   961         }

   962     else

   963         {

   964         CUpnpAction* action = NULL;

   965         TInt err( KErrNone );

   966         err = iCdsActionFactory->CdsSearchActionLC(

   967             action,

   968             (CUpnpDevice*)device,

   969             aObjectId,

   970             aSearchCriteria,

   971             aFilter,

   972             aStartingIndex,

   973             aRequestedCount,

   974             aSortCriteria

   975             );

   976 

   977         if( err == KErrNone )

   978             {

   979             

   980             SendL( action );

   981             CleanupStack::Pop( action );

   982 

   983             return action->SessionId();

   984             }

   985         else

   986             {

   987             return err;

   988             }

   989         }

   990     }

   991 

   992 // -----------------------------------------------------------------------------

   993 // CUpnpAVControlPoint::CdsSystemUpdateIdActionL

   994 // This function creates and sends a action.

   995 // (other items were commented in a header)

   996 // -----------------------------------------------------------------------------

   997 //

   998 EXPORT_C TInt CUpnpAVControlPoint::CdsSystemUpdateIdActionL(const TDesC8& aUuid)

   999     {

  1000     const CUpnpDevice* device = Device( aUuid );

  1001     if( !device ) 

  1002         {

  1003         return KErrBadHandle;

  1004         }

  1005     else

  1006         {

  1007         CUpnpAction* action = NULL;

  1008         TInt err( KErrNone );

  1009         err = iCdsActionFactory->CdsSystemUpdateIdActionLC(

  1010             action,

  1011             (CUpnpDevice*)device

  1012             );

  1013 

  1014         if( err == KErrNone )

  1015             {

  1016             

  1017             SendL( action );

  1018             CleanupStack::Pop( action );

  1019 

  1020             return action->SessionId();

  1021             }

  1022         else

  1023             {

  1024             return err;

  1025             }

  1026         }

  1027     }

  1028 

  1029 // -----------------------------------------------------------------------------

  1030 // CUpnpAVControlPoint::CdsSearchCapabilitiesActionL

  1031 // This function creates and sends a action.

  1032 // (other items were commented in a header)

  1033 // -----------------------------------------------------------------------------

  1034 //

  1035 EXPORT_C TInt CUpnpAVControlPoint::CdsSearchCapabilitiesActionL(const TDesC8& aUuid)

  1036     {

  1037     const CUpnpDevice* device = Device( aUuid );

  1038     if( !device ) 

  1039         {

  1040         return KErrBadHandle;

  1041         }

  1042     else

  1043         {

  1044         CUpnpAction* action = NULL;

  1045         TInt err( KErrNone );

  1046         err = iCdsActionFactory->CdsSearchCapabilitiesActionLC(

  1047             action,

  1048             (CUpnpDevice*)device

  1049             );

  1050 

  1051         if( err == KErrNone )

  1052             {

  1053             

  1054             SendL( action );

  1055             CleanupStack::Pop( action );

  1056 

  1057             return action->SessionId();

  1058             }

  1059         else

  1060             {

  1061             return err;

  1062             }

  1063         }

  1064     }

  1065 

  1066 // -----------------------------------------------------------------------------

  1067 // CUpnpAVControlPoint::CdsSortCapabilitiesActionL

  1068 // This function creates and sends a action.

  1069 // (other items were commented in a header)

  1070 // -----------------------------------------------------------------------------

  1071 //

  1072 EXPORT_C TInt CUpnpAVControlPoint::CdsSortCapabilitiesActionL(const TDesC8& aUuid)

  1073     {

  1074     const CUpnpDevice* device = Device( aUuid );

  1075     if( !device ) 

  1076         {

  1077         return KErrBadHandle;

  1078         }

  1079     else

  1080         {

  1081         CUpnpAction* action = NULL;

  1082         TInt err( KErrNone );

  1083         err = iCdsActionFactory->CdsSortCapabilitiesActionLC(

  1084             action,

  1085             (CUpnpDevice*)device

  1086             );

  1087 

  1088         if( err == KErrNone )

  1089             {

  1090             

  1091             SendL( action );

  1092             CleanupStack::Pop( action );

  1093 

  1094             return action->SessionId();

  1095             }

  1096         else

  1097             {

  1098             return err;

  1099             }

  1100         }

  1101     }

  1102 

  1103 // -----------------------------------------------------------------------------

  1104 // CUpnpAVControlPoint::CdsCreateObjectActionL

  1105 // This function creates and sends a action.

  1106 // (other items were commented in a header)

  1107 // -----------------------------------------------------------------------------

  1108 //                                                                                               

  1109 EXPORT_C TInt CUpnpAVControlPoint::CdsCreateObjectActionL(const TDesC8& aUuid,

  1110                                               const TDesC8& aId, 

  1111                                               const TDesC8& aElements)

  1112     {

  1113     const CUpnpDevice* device = Device( aUuid );

  1114     if( !device ) 

  1115         {

  1116         return KErrBadHandle;

  1117         }

  1118     else

  1119         {

  1120         CUpnpAction* action = NULL;

  1121         TInt err( KErrNone );

  1122         err = iCdsActionFactory->CdsCreateObjectActionLC(

  1123             action,

  1124             (CUpnpDevice*)device,

  1125             aId,

  1126             aElements

  1127             );

  1128 

  1129         if( err == KErrNone )

  1130             {

  1131             

  1132             SendL( action );

  1133             CleanupStack::Pop( action );

  1134 

  1135             return action->SessionId();