1 /*

     2 * Copyright (c) 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:      AV Controller Implementation

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 #ifndef C_UPNPAVCONTROLLERIMPL_H

    25 #define C_UPNPAVCONTROLLERIMPL_H

    26 

    27 // INDLUDE FILES

    28 #include <e32base.h>

    29 #include <upnpavcontrolpointobserver.h>

    30 #include <upnpmediaserverclient.h>

    31 #include "upnpavcontrollerglobals.h"

    32 #include "upnpconnectionmonitorobserver.h"

    33 

    34 // FORWARD DECLARATIONS

    35 class MUPnPAVDeviceObserver;

    36 class MUPnPAVMediaObserver;

    37 class MUPnPAVFileObserver;

    38 class CUPnPPlaybackSession;

    39 class CUpnpAVControllerServer;

    40 class CUpnpAVDevice;

    41 class CUpnpHttpMessage;

    42 class CUpnpDevice;

    43 class CUpnpAVDeviceExtended;

    44 class CUPnPBrowsingSession;

    45 class CUpnpDeviceDiscoveryMessage;

    46 

    47 class CUPnPUploadSession;

    48 class CUPnPDownloadSession;

    49 

    50 /**

    51  *  AV Controller server side implementation. Impmements the base session. 

    52  *  Rendering and browsing sessions are created from this session.

    53  *  Handles device discovery and fetching of device listst.

    54  *

    55  *  @lib upnpavcontrollerclient.lib

    56  *  @since S60 v3.1

    57  */

    58 class CUPnPAVControllerImpl :   public CBase,

    59                                 public MUPnPConnectionMonitorObserver

    60                                 

    61     {

    62 

    63 public:

    64 

    65     /**

    66      * Two-phased constructor.

    67      *

    68      * @param aControlPoint control point reference

    69      * @param aClient media server client reference

    70      * @param aDispatcher callback dispatcher reference

    71      * @param aServer server class reference

    72      */

    73     static CUPnPAVControllerImpl* NewL

    74         (

    75         RUpnpMediaServerClient& aClient,

    76         CUpnpAVControllerServer& aServer

    77         );

    78     

    79     /**

    80      * Destructor

    81      */

    82     virtual ~CUPnPAVControllerImpl();

    83     

    84 private:

    85 

    86     /**

    87      * Private constructor

    88      *

    89      * @param aControlPoint control point reference

    90      * @param aClient media server client reference

    91      * @param aDispatcher callback dispatcher reference

    92      * @param aServer server class reference          

    93      */

    94     CUPnPAVControllerImpl

    95     (

    96     RUpnpMediaServerClient& aClient,

    97     CUpnpAVControllerServer& aServer

    98     );    

    99     

   100     /**

   101      * Destructor

   102      */

   103     void ConstructL();    

   104 

   105 public: // From MUPnPConnectionMonitorObserver

   106     

   107     /**

   108      * See upnpconnectionmonitorobserver.h

   109      */

   110     void ConnectionLost();

   111     

   112 public: // New functions

   113 

   114     /**

   115      * Handles UPnP device discoveries.

   116      * @since Series 60 2.6

   117      * @param aDevice Device that is discovered.

   118      */

   119     void DeviceDiscoveredL( CUpnpAVDeviceExtended& aDevice );

   120 

   121     /**

   122      * Handles UPnP device disappears.

   123      * @since Series 60 2.6

   124      * @param aDevice Device that disappeared.

   125      */

   126     void DeviceDisappearedL( CUpnpAVDeviceExtended& aDevice );

   127     

   128 

   129     /**

   130      * Enables device discovery by storing a message to server side, which

   131      * is completed when a device has been discovered.

   132      *

   133      * @param aMessage message

   134      */

   135     void EnableDeviceDiscoveryL( const RMessage2& aMessage );

   136         

   137     /**

   138      * Disables (cancels) device discovery (and message).

   139      */

   140     void DisableDeviceDiscoveryL();

   141     

   142     /**

   143      * Returns a discovered/disappeared device to client side.

   144      *

   145      * @param aMessage message

   146      */

   147     void GetDeviceL( const RMessage2& aMessage );

   148     

   149     /**

   150      * Returns the size of device list to client side.

   151      *

   152      * @param aMessage message

   153      */

   154     void GetDeviceListSizeL( const RMessage2& aMessage );

   155     

   156     /**

   157      * Returns the device list to client side.

   158      *

   159      * @param aMessage message

   160      */

   161     void GetDeviceListL( const RMessage2& aMessage );

   162     

   163     /**

   164      * Creates a rendering session.

   165      *

   166      * @param aMessage message

   167      */

   168     void CreateRenderingSessionL( const RMessage2& aMessage );

   169     

   170     /**

   171      * Destroys a rendering session

   172      *

   173      * @param aMessage message

   174      */

   175     void DestroyRenderingSessionL( const RMessage2& aMessage );

   176     

   177     /**

   178      * Enables (unsolicited) eventing from a remote device. Stores

   179      * the message in to redering session to return an event.

   180      *

   181      * @param aMessage message

   182      */

   183     void EventRequestL( const RMessage2& aMessage );

   184     

   185     /**

   186      * Cancels eventing message.

   187      *

   188      * @param aMessage message

   189      */

   190     void CancelEventRequestL( const RMessage2& aMessage );

   191     

   192     /**

   193      * Sets URI

   194      *

   195      * @param aMessage message

   196      */

   197     void SetURIL( const RMessage2& aMessage );

   198     

   199     /**

   200      * Cancels SetURI (basically just ignores the result)

   201      *

   202      * @param aMessage message

   203      */

   204     void CancelSetURIL( const RMessage2& aMessage );

   205     

   206     /**

   207      * Sets Next URI

   208      *

   209      * @param aMessage message

   210      */

   211     void SetNextURIL( const RMessage2& aMessage );

   212     

   213     /**

   214      * Cancels SetNextURI (basically just ignores the result)

   215      *

   216      * @param aMessage message

   217      */

   218     void CancelSetNextURIL( const RMessage2& aMessage );

   219     

   220     /**

   221      * Send the play-action

   222      *

   223      * @param aMessage message

   224      */

   225     void PlayL( const RMessage2& aMessage );

   226     

   227     /**

   228      * Cancels the play-action (basically just ignores the result)

   229      *

   230      * @param aMessage message

   231      */

   232     void CancelPlayL( const RMessage2& aMessage );

   233 

   234     /**

   235      * Send the stop-action

   236      *

   237      * @param aMessage message

   238      */

   239     void StopL( const RMessage2& aMessage );

   240     

   241     /**

   242      * Cancels stop (basically just ignores the result)

   243      *

   244      * @param aMessage message

   245      */

   246     void CancelStopL( const RMessage2& aMessage );

   247 

   248     /**

   249      * Send the pause-action

   250      *

   251      * @param aMessage message

   252      */

   253     void PauseL( const RMessage2& aMessage );

   254     

   255     /**

   256      * Cancels pause (basically just ignores the result)

   257      *

   258      * @param aMessage message

   259      */

   260     void CancelPauseL( const RMessage2& aMessage );

   261 

   262     /**

   263      * Send the setvolume-action

   264      *

   265      * @param aMessage message

   266      */

   267     void SetVolumeL( const RMessage2& aMessage );

   268     

   269     /**

   270      * Cancels setvolume (basically just ignores the result)

   271      *

   272      * @param aMessage message

   273      */

   274     void CancelSetVolumeL( const RMessage2& aMessage );

   275     

   276     /**

   277      * Send the getvolume-action

   278      *

   279      * @param aMessage message

   280      */

   281     void GetVolumeL( const RMessage2& aMessage );

   282     

   283     /**

   284      * Cancels getvolume (basically just ignores the result)

   285      *

   286      * @param aMessage message

   287      */

   288     void CancelGetVolumeL( const RMessage2& aMessage );

   289     

   290     /**

   291      * Send the setmute-action

   292      *

   293      * @param aMessage message

   294      */

   295     void SetMuteL( const RMessage2& aMessage );

   296     

   297     /**

   298      * Cancels setmute (basically just ignores the result)

   299      *

   300      * @param aMessage message

   301      */

   302     void CancelSetMuteL( const RMessage2& aMessage );

   303     

   304     /**

   305      * Send the getmute-action

   306      *

   307      * @param aMessage message

   308      */

   309     void GetMuteL( const RMessage2& aMessage );

   310     

   311     /**

   312      * Cancels getmute (basically just ignores the result)

   313      *

   314      * @param aMessage message

   315      */

   316     void CancelGetMuteL( const RMessage2& aMessage );

   317     

   318     /**

   319      * Send the getpositioninfo-action

   320      *

   321      * @param aMessage message

   322      */

   323     void GetPositionInfoL( const RMessage2& aMessage );

   324     

   325     /**

   326      * Cancels getpositioninfo (basically just ignores the result)

   327      *

   328      * @param aMessage message

   329      */

   330     void CancelGetPositionInfoL( const RMessage2& aMessage );

   331     

   332     /**

   333      * Create a browsing session

   334      *

   335      * @param aMessage message

   336      */

   337     void CreateBrowsingSessionL( const RMessage2& aMessage );

   338     

   339     /**

   340      * Destroy a browsing session

   341      *

   342      * @param aMessage message

   343      */

   344     void DestroyBrowsingSessionL( const RMessage2& aMessage );

   345     

   346     /**

   347      * Get browse response (return the size of it to client side)

   348      *

   349      * @param aMessage message

   350      */

   351     void GetBrowseResponseSizeL( const RMessage2& aMessage );  

   352 

   353     /**

   354      * Cancel get browse response (ignore result)

   355      *

   356      * @param aMessage message

   357      */

   358     void CancelGetBrowseResponseSizeL( const RMessage2& aMessage );

   359 

   360     /**

   361      * Return browse response to client side

   362      *

   363      * @param aMessage message

   364      */

   365     void GetBrowseResponseL( const RMessage2& aMessage );

   366 

   367     /**

   368      * Get search response (return the size of it to client side)

   369      *

   370      * @param aMessage message

   371      */

   372     void GetSearchResponseSizeL( const RMessage2& aMessage );

   373 

   374     /**

   375      * Cancel search response (ignore result)

   376      *

   377      * @param aMessage message

   378      */

   379     void CancelGetSearchResponseSizeL( const RMessage2& aMessage );

   380 

   381     /**

   382      * Return search response to client side

   383      *

   384      * @param aMessage message

   385      */

   386     void GetSearchResponseL( const RMessage2& aMessage );

   387     

   388     /**

   389      * Get search capabilities (return the size of it to client side)

   390      *

   391      * @param aMessage message

   392      */

   393     void GetSearchCapabitiesSizeL( const RMessage2& aMessage );

   394     

   395     /**

   396      * Cancel get search capabilities (ignore result)

   397      *

   398      * @param aMessage message

   399      */

   400     void CancelGetSearchCapabitiesSizeL( const RMessage2& aMessage );

   401     

   402     /**

   403      * Return search capabilities to client side

   404      *

   405      * @param aMessage message

   406      */

   407     void GetSearchCapabitiesL( const RMessage2& aMessage );

   408 

   409     /**

   410      * Create container action.

   411      *

   412      * @param aMessage message

   413      */

   414     void CreateContainerL( const RMessage2& aMessage );

   415     

   416     /**

   417      * Cancels create container.

   418      *

   419      * @param aMessage message

   420      */

   421     void CancelCreateContainerL( const RMessage2& aMessage );

   422     

   423     /**

   424      * Delete object action

   425      *

   426      * @param aMessage message

   427      */

   428     void DeleteObjectL( const RMessage2& aMessage );

   429     

   430     /**

   431      * Cancels delete object

   432      *

   433      * @param aMessage message

   434      */

   435     void CancelDeleteObjectL( const RMessage2& aMessage );

   436 

   437     /**

   438      * Stores a message in to rendering or browsing session, which is

   439      * completed when the session specific device has disappeared. As a

   440      * result the client knows that the device is no longer available and

   441      * the session has became absolete.

   442      *

   443      * @param aMessage message

   444      */

   445     void DeviceDisappearedRequestL( const RMessage2& aMessage );

   446     

   447     /**

   448      * Cancels the msg.

   449      *

   450      * @param aMessage message

   451      */

   452     void CancelDeviceDisappearedRequestL( const RMessage2& aMessage );

   453     

   454     /**

   455      * Stores a message in to base session, which is completed when the

   456      * WLAN is disconnected.

   457      *

   458      * @param aMessage message

   459      */

   460     void MonitorConnectionL( const RMessage2& aMessage );

   461     

   462     /**

   463      * Cancels the msg.

   464      *

   465      * @param aMessage message

   466      */

   467     void CancelMonitorConnectionL( const RMessage2& aMessage );

   468 

   469     void CreateDownloadSessionL( const RMessage2& aMessage );

   470     

   471     void DestroyDownloadSessionL( const RMessage2& aMessage );

   472 

   473     void StartDownloadL( const RMessage2& aMessage );

   474     

   475     void StartDownloadFHL( const RMessage2& aMessage );

   476     

   477     void CancelDownloadL( const RMessage2& aMessage );

   478 

   479     void CancelAllDownloadsL( const RMessage2& aMessage );

   480     

   481     void StartTrackingDownloadProgressL( const RMessage2& aMessage );

   482 

   483     void StopTrackingDownloadProgressL( const RMessage2& aMessage );

   484 

   485     void GetDownloadEventL( const RMessage2& aMessage );

   486     

   487     void CancelGetDownloadEventL( const RMessage2& aMessage );

   488 

   489     void CreateUploadSessionL( const RMessage2& aMessage );

   490     

   491     void DestroyUploadSessionL( const RMessage2& aMessage );    

   492 

   493     void StartUploadL( const RMessage2& aMessage );

   494     

   495     void CancelUploadL( const RMessage2& aMessage );

   496 

   497     void CancelAllUploadsL( const RMessage2& aMessage );

   498     

   499     void StartTrackingUploadProgressL( const RMessage2& aMessage );

   500 

   501     void StopTrackingUploadProgressL( const RMessage2& aMessage );

   502 

   503     void GetUploadEventL( const RMessage2& aMessage );

   504     

   505     void CancelGetUploadEventL( const RMessage2& aMessage );

   506 

   507 private:

   508 

   509     /**

   510      * Device queu handling. Checks the queu and dequeus it if needed.

   511      *

   512      * @param aDevice av device

   513      * @param aType discovered/disappeared

   514      */

   515     void DequeDeviceL( const CUpnpAVDevice& aDevice,

   516         TAVControllerDeviceDiscovery aType );

   517 

   518 private:

   519     

   520     RUpnpMediaServerClient&     iMediaServer; // Not own       

   521     

   522     CUpnpAVControllerServer&    iServer; // Not own       

   523     

   524     RMessage2*                  iDeviceDiscoveryMsg; // Own

   525     

   526     TBool                       iDeviceDiscoveryEnabled;

   527     

   528     RMessage2*                  iConnectionMsg; // Own

   529     

   530     HBufC8*                     iDeviceRespBuf; // Own

   531     

   532     HBufC8*                     iDeviceListRespBuf; // Own

   533     

   534     RPointerArray<CUPnPPlaybackSession> iPlaybackSessions; // Own

   535     

   536     RPointerArray<CUPnPBrowsingSession> iBrowsingSessions; // Own

   537     

   538     RPointerArray<CUPnPUploadSession>   iUploadSessions; // Own

   539     

   540     RPointerArray<CUPnPDownloadSession> iDownloadSessions; // Own

   541     

   542     

   543     TSglQue<CUpnpDeviceDiscoveryMessage>        iDeviceMsgQue; // Own

   544     TSglQueIter<CUpnpDeviceDiscoveryMessage>    iDeviceMsgQueIter;

   545     };

   546 

   547 #endif // C_UPNPAVCONTROLLERIMPL_H