1 /*

     2 * Copyright (c) 2004 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 class CDRMEventHandler

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <s32mem.h> 

    22 #include "DRMEventHandler.h"

    23 #include "drmnotifierclientserver.h"

    24 

    25 // EXTERNAL DATA STRUCTURES

    26 // EXTERNAL FUNCTION PROTOTYPES  

    27 // CONSTANTS

    28 // MACROS

    29 // LOCAL CONSTANTS AND MACROS

    30 // MODULE DATA STRUCTURES

    31 // LOCAL FUNCTION PROTOTYPES

    32 // FORWARD DECLARATIONS

    33 

    34 // ============================ MEMBER FUNCTIONS ===============================

    35 

    36 // -----------------------------------------------------------------------------

    37 // CDRMEventHandler::NewL

    38 // Two-phased constructor.

    39 // -----------------------------------------------------------------------------

    40 //

    41 CDRMEventHandler* CDRMEventHandler::NewL()

    42     {

    43     CDRMEventHandler* self = new( ELeave ) CDRMEventHandler;

    44     

    45     CleanupStack::PushL( self );

    46     self->ConstructL();

    47     CleanupStack::Pop();

    48 

    49     return self;

    50     }

    51 

    52 // -----------------------------------------------------------------------------

    53 // CDRMEventHandler::~CDRMEventHandler

    54 // Destructor.

    55 // -----------------------------------------------------------------------------

    56 //

    57 CDRMEventHandler::~CDRMEventHandler()

    58 {

    59     if( iHandler )

    60         {

    61         Cancel();

    62         }

    63 

    64     if( iData )

    65         {

    66         delete iData;

    67         iData = NULL;

    68         }

    69     if( iDataBuffer )

    70         {

    71         delete iDataBuffer;

    72         iDataBuffer = NULL;

    73         }

    74     if( iEventType )

    75         {

    76         delete iEventType;

    77         iEventType = NULL;

    78         }

    79 

    80     if( iWaitData )

    81         {

    82         delete iWaitData;

    83         iWaitData = NULL;

    84         }

    85     if( iWaitDataBuffer )

    86         {

    87         delete iWaitDataBuffer;

    88         iWaitDataBuffer = NULL;

    89         }

    90     if( iEventTypeWait )

    91         {

    92         delete iEventTypeWait;

    93         iEventTypeWait = NULL;

    94         }

    95 

    96     if ( iAddRemoveObservers ) 

    97         {

    98         for( TInt i = 0; i < iAddRemoveObservers->Count();i++)

    99             {

   100             delete (*iAddRemoveObservers)[i]->iContentID;

   101             (*iAddRemoveObservers)[i]->iContentID = NULL;

   102             }

   103         iAddRemoveObservers->Reset();

   104         delete iAddRemoveObservers;

   105         iAddRemoveObservers = NULL;

   106         }

   107     if ( iModifyObservers ) 

   108         {

   109         for( TInt i = 0; i < iModifyObservers->Count();i++)

   110             {

   111             delete (*iModifyObservers)[i]->iContentID;

   112             (*iModifyObservers)[i]->iContentID = NULL;

   113             }

   114         iModifyObservers->Reset();

   115         delete iModifyObservers;

   116         iModifyObservers = NULL;

   117         }

   118         

   119     if ( iTimeChangeObservers ) 

   120         {

   121         iTimeChangeObservers->Reset();

   122         delete iTimeChangeObservers;

   123         iTimeChangeObservers = NULL;

   124         }

   125                 

   126     if ( iDelayedObservers )

   127         {

   128         for( TInt i = 0; i < iDelayedObservers->Count();i++)

   129             {

   130             delete (*iDelayedObservers)[i]->iContentID;

   131             (*iDelayedObservers)[i]->iContentID = NULL;

   132             }

   133         iDelayedObservers->Reset();

   134         delete iDelayedObservers;

   135         iDelayedObservers = NULL;

   136         }

   137 

   138     if( iHandler )

   139         {

   140         iHandler->Close();

   141         delete iHandler;

   142         iHandler = NULL;

   143         }

   144     }

   145 

   146 

   147 // -----------------------------------------------------------------------------

   148 // CDRMEventHandler::RegisterEventObserverL

   149 // Adds the new handler to the list of handlers.

   150 // Checks if the handler is already in the list

   151 // Sets the active object active if it is not active yet.

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

   153 //

   154 void CDRMEventHandler::RegisterEventObserverL(

   155     MDRMEventObserver& aObserver,

   156     const TDRMEventType& aEvent )

   157     {

   158 

   159     TInt count = 0;

   160     TBool addToServer = ETrue;

   161     

   162     

   163     if( iIsDelayed )

   164         {

   165         TDelayedObserverData* delayData = new (ELeave) TDelayedObserverData;

   166         CleanupStack::PushL( delayData);

   167         delayData->iRequest = KRegisterOperation;

   168         delayData->iObserver = &aObserver;

   169         delayData->iEventType = aEvent;

   170         delayData->iContentID = NULL;

   171         iDelayedObservers->AppendL( delayData );

   172         CleanupStack::Pop();    // delayData;

   173         return;

   174         }

   175 

   176     switch ( aEvent )

   177         {

   178         case KEventAddRemove:

   179             if ( iAddRemoveObservers )

   180                 {

   181                 for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

   182                     {

   183                     if ( ( *iAddRemoveObservers )[ count ]->iObserver == &aObserver &&

   184                          !( *iAddRemoveObservers )[ count ]->iContentID )

   185                         {

   186                         return;

   187                         }

   188                     else if( addToServer && !( *iAddRemoveObservers)[ count ]->iContentID ) 

   189                         {

   190                         addToServer = EFalse;

   191                         }

   192                     }

   193                 }

   194             break;

   195         case KEventModify:

   196             if ( iModifyObservers )

   197                 {

   198                 for ( count = 0; count < iModifyObservers->Count(); ++count )

   199                     {

   200                     if ( ( *iModifyObservers )[ count ]->iObserver == &aObserver &&

   201                          !( *iModifyObservers )[ count ]->iContentID )

   202                         {

   203                         return;

   204                         }

   205                     else if( addToServer && !( *iModifyObservers)[ count ]->iContentID ) 

   206                         {

   207                         addToServer = EFalse;

   208                         }

   209                     }

   210                 }

   211             break;

   212         case KEventTimeChange:

   213             if ( iTimeChangeObservers )        

   214                 {

   215                 for ( count = 0; count < iTimeChangeObservers->Count(); ++count )

   216                     {

   217                     if ( ( *iTimeChangeObservers )[ count ]->iObserver == &aObserver )

   218                         {

   219                         return;

   220                         }

   221                     }

   222                 }      

   223             break;

   224         default:

   225             User::Leave(KErrArgument);

   226             break;

   227         }  

   228 

   229     struct TObserverData* observer = new (ELeave) TObserverData;

   230     CleanupStack::PushL(observer);

   231 

   232     observer->iObserver = &aObserver;

   233     observer->iContentID = NULL;

   234 

   235     switch( aEvent )

   236         {

   237         case KEventAddRemove:

   238             iAddRemoveObservers->AppendL( observer );

   239             break;

   240         case KEventModify:

   241             iModifyObservers->AppendL( observer );

   242             break;

   243         case KEventTimeChange:

   244             iTimeChangeObservers->AppendL( observer );

   245             break;

   246         default:

   247             User::Leave(KErrArgument);

   248             break;

   249         }

   250    

   251     if ( !IsAdded() )

   252         {

   253         CActiveScheduler::Add( this );

   254         }

   255 

   256     if ( !IsActive() )

   257         {

   258         if( iStatus != KRequestPending )

   259             {

   260             iStatus = KRequestPending;

   261             iHandler->WaitForCompletion(iStatus);

   262             }

   263         SetActive();

   264         }

   265 

   266     // Register the type to the server

   267     if( addToServer )

   268         {

   269         iHandler->RegisterForType(aEvent);

   270         }

   271 

   272     CleanupStack::Pop(); // observer

   273     }

   274 

   275 // -----------------------------------------------------------------------------

   276 // CDRMEventHandler::UnRegisterEventObserverL

   277 // Removes the observer from the list of handlers.

   278 // -----------------------------------------------------------------------------

   279 //

   280 void CDRMEventHandler::UnRegisterEventObserverL( 

   281     MDRMEventObserver& aObserver,

   282     const TDRMEventType& aEvent)

   283     {

   284     TInt count = 0;

   285     TBool removeFromServer = ETrue;

   286 

   287     if( iIsDelayed )

   288         {

   289         TDelayedObserverData* delayData = new (ELeave) TDelayedObserverData;

   290         CleanupStack::PushL( delayData);

   291         delayData->iRequest = KUnRegisterOperation;

   292         delayData->iObserver = &aObserver;

   293         delayData->iEventType = aEvent;

   294         delayData->iContentID = NULL;

   295         iDelayedObservers->AppendL( delayData );

   296         CleanupStack::Pop();    // delayData;

   297         return;

   298         }

   299 

   300     // Check if something else uses the registration for this event type, if something

   301     // Does set removeFromServer to EFalse so the registration is not removed from the

   302     // server

   303     switch ( aEvent )

   304         {

   305         case KEventAddRemove:

   306             if ( iAddRemoveObservers )

   307                 {

   308                 for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

   309                     {

   310                     if( removeFromServer && !( *iAddRemoveObservers)[ count ]->iContentID &&

   311                         ( *iAddRemoveObservers)[ count ]->iObserver != &aObserver ) 

   312                         {

   313                         removeFromServer = EFalse;

   314                         }

   315                     }

   316                 }

   317             break;

   318         case KEventModify:

   319             if ( iModifyObservers )

   320                 {

   321                 for ( count = 0; count < iModifyObservers->Count(); ++count )

   322                     {

   323                     if( removeFromServer && !( *iModifyObservers)[ count ]->iContentID &&

   324                         ( *iModifyObservers)[ count ]->iObserver != &aObserver ) 

   325                         {

   326                         removeFromServer = EFalse;

   327                         }

   328                     }

   329                 }

   330             break;

   331         case KEventTimeChange:

   332             if ( iTimeChangeObservers )

   333                 {

   334                 for ( count = 0; count < iTimeChangeObservers->Count(); ++count )

   335                     {

   336                     if( ( *iTimeChangeObservers)[ count ]->iObserver != &aObserver ) 

   337                         {

   338                         removeFromServer = EFalse;

   339                         }

   340                     }

   341                 }

   342             break;        

   343         default:

   344             User::Leave(KErrArgument);

   345             break;

   346         }  

   347 

   348 

   349     // Remove the registrations from internal lists and possibly from the server

   350     switch ( aEvent )

   351         {

   352         case KEventAddRemove:

   353             if ( iAddRemoveObservers )

   354                 {

   355                 for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

   356                     {

   357                     if ( ( *iAddRemoveObservers )[ count ]->iObserver == &aObserver &&

   358                          !( *iAddRemoveObservers )[ count ]->iContentID )

   359                         {

   360                         if( removeFromServer )

   361                             {

   362                             // Unregister the type from the server

   363                             iHandler->UnRegisterFromType(aEvent);

   364                             }

   365 

   366                         // Free Memory

   367                         delete ( *iAddRemoveObservers )[ count ];

   368                         ( *iAddRemoveObservers )[ count ] = NULL;

   369 

   370                         // Delete the element from the table

   371                         iAddRemoveObservers->Delete( count );

   372                         iAddRemoveObservers->Compress();

   373                         return;

   374                         }

   375                     }

   376                 }

   377             User::Leave(KErrNotFound);

   378             break;

   379         case KEventModify:

   380             if ( iModifyObservers )

   381                 {

   382                 for ( count = 0; count < iModifyObservers->Count(); ++count )

   383                     {

   384                     if ( ( *iModifyObservers )[ count ]->iObserver == &aObserver &&

   385                          !( *iModifyObservers )[ count ]->iContentID )

   386                         {

   387                         if( removeFromServer )

   388                             {

   389                             // Unregister the type from the server

   390                             iHandler->UnRegisterFromType(aEvent);

   391                             }

   392 

   393                         // Free Memory

   394                         delete ( *iModifyObservers )[ count ];

   395                         ( *iModifyObservers )[ count ] = NULL;

   396 

   397                         // Delete the element from the table

   398                         iModifyObservers->Delete( count );

   399                         iModifyObservers->Compress();

   400                         return;

   401                         }

   402                     }

   403                 }

   404             User::Leave(KErrNotFound);

   405             break;

   406         case KEventTimeChange:

   407             if ( iTimeChangeObservers )

   408                 {

   409                 for ( count = 0; count < iTimeChangeObservers->Count(); ++count )

   410                     {

   411                     if ( ( *iTimeChangeObservers )[ count ]->iObserver == &aObserver )

   412                         {

   413                         if( removeFromServer )

   414                             {

   415                             // Unregister the type from the server

   416                             iHandler->UnRegisterFromType(aEvent);

   417                             }

   418 

   419                         // Free Memory

   420                         delete ( *iTimeChangeObservers )[ count ];

   421                         ( *iTimeChangeObservers )[ count ] = NULL;

   422 

   423                         // Delete the element from the table

   424                         iTimeChangeObservers->Delete( count );

   425                         iTimeChangeObservers->Compress();

   426                         return;

   427                         }

   428                     }

   429                 }

   430             User::Leave(KErrNotFound);        

   431             break;

   432         default:

   433             User::Leave(KErrArgument);

   434             break;

   435         }  

   436     // Should never get here

   437     User::Leave( KErrGeneral );

   438     }

   439 

   440 // -----------------------------------------------------------------------------

   441 // CDRMEventHandler::RegisterEventObserverL

   442 // Adds the new handler to the list of handlers.

   443 // Checks is the handler is already in the list

   444 // Sets the active object active if it is not active yet.

   445 // -----------------------------------------------------------------------------

   446 //

   447 void CDRMEventHandler::RegisterEventObserverL(

   448     MDRMEventObserver& aObserver,

   449     const TDRMEventType& aEvent,

   450     const TDesC8& aContentID )

   451     {

   452     TInt count = 0;

   453     TBool addToServer = ETrue;

   454 

   455     if( iIsDelayed )

   456         {

   457         TDelayedObserverData* delayData = new (ELeave) TDelayedObserverData;

   458         CleanupStack::PushL( delayData);

   459         delayData->iRequest = KRegisterURIOperation;

   460         delayData->iObserver = &aObserver;

   461         delayData->iEventType = aEvent;

   462         delayData->iContentID = aContentID.AllocLC();

   463         iDelayedObservers->AppendL( delayData );

   464         CleanupStack::Pop();    // iContentID;

   465         CleanupStack::Pop();    // delayData;

   466         return;

   467         }

   468 

   469     switch ( aEvent )

   470         {

   471         case KEventAddRemove:

   472             if ( iAddRemoveObservers )

   473                 {

   474                 for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

   475                     {

   476                     if ( ( *iAddRemoveObservers )[ count ]->iObserver == &aObserver &&

   477                          ( *iAddRemoveObservers )[ count ]->iContentID &&

   478                          !( *iAddRemoveObservers )[ count ]->iContentID->Compare( aContentID ) )

   479                         {

   480                         return;

   481                         }

   482                     else if( addToServer && 

   483                         !( *iAddRemoveObservers)[ count ]->iContentID->Compare( aContentID ) ) 

   484                         {

   485                         addToServer = EFalse;

   486                         }

   487                     }

   488                 }

   489             break;

   490         case KEventModify:

   491             if ( iModifyObservers )

   492                 {

   493                 for ( count = 0; count < iModifyObservers->Count(); ++count )

   494                     {

   495                     if ( ( *iModifyObservers )[ count ]->iObserver == &aObserver &&

   496                          ( *iModifyObservers )[ count ]->iContentID &&

   497                          !( *iModifyObservers )[ count ]->iContentID->Compare( aContentID ) )

   498                         {

   499                         return;

   500                         }

   501                     else if( addToServer && 

   502                         !( *iModifyObservers)[ count ]->iContentID->Compare( aContentID ) ) 

   503                         {

   504                         addToServer = EFalse;

   505                         }

   506                     }

   507                 }

   508             break;

   509         default:

   510             User::Leave(KErrArgument);

   511             break;

   512         }  

   513 

   514     HBufC8* contentID = aContentID.AllocLC();

   515     struct TObserverData* observer = new (ELeave) TObserverData;

   516     CleanupStack::PushL(observer);

   517 

   518     observer->iObserver = &aObserver;

   519     observer->iContentID = contentID;

   520 

   521     switch( aEvent )

   522         {

   523         case KEventAddRemove:

   524             iAddRemoveObservers->AppendL( observer );

   525             break;

   526         case KEventModify:

   527             iModifyObservers->AppendL( observer );

   528             break;

   529         default:

   530             User::Leave(KErrArgument);

   531             break;

   532         }

   533    

   534     if ( !IsAdded() )

   535         {

   536         CActiveScheduler::Add( this );

   537         }

   538 

   539     if ( !IsActive() )

   540         {

   541         if( iStatus != KRequestPending )

   542             {

   543             iStatus = KRequestPending;

   544             iHandler->WaitForCompletion(iStatus);

   545             }

   546         SetActive();

   547         }

   548 

   549     // Register the type to the server

   550     if ( addToServer )

   551         {

   552         iHandler->RegisterForType(aEvent,contentID);

   553         }

   554 

   555     CleanupStack::Pop(); // contentID

   556     CleanupStack::Pop(); // observer;

   557     }

   558 

   559 // -----------------------------------------------------------------------------

   560 // CDRMEventHandler::UnRegisterEventObserverL

   561 // Removes the observer from the list of handlers.

   562 // -----------------------------------------------------------------------------

   563 //

   564 void CDRMEventHandler::UnRegisterEventObserverL( 

   565     MDRMEventObserver& aObserver,

   566     const TDRMEventType& aEvent,

   567     const TDesC8& aContentID )

   568     {

   569     TInt count = 0;

   570     TBool removeFromServer = ETrue;

   571 

   572     if( iIsDelayed )

   573         {

   574         TDelayedObserverData* delayData = new (ELeave) TDelayedObserverData;

   575         CleanupStack::PushL( delayData);

   576         delayData->iRequest = KUnRegisterURIOperation;

   577         delayData->iObserver = &aObserver;

   578         delayData->iEventType = aEvent;

   579         delayData->iContentID = aContentID.AllocLC();

   580         iDelayedObservers->AppendL( delayData );

   581         CleanupStack::Pop();    // iContentID;

   582         CleanupStack::Pop();    // delayData;

   583         return;

   584         }

   585 

   586     // Check if something else uses the registration for this event type, if something

   587     // Does set removeFromServer to EFalse so the registration is not removed from the

   588     // server

   589     switch ( aEvent )

   590         {

   591         case KEventAddRemove:

   592             if ( iAddRemoveObservers )

   593                 {

   594                 for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

   595                     {

   596                     if( removeFromServer && 

   597                         !( *iAddRemoveObservers )[ count ]->iContentID->Compare( aContentID ) &&

   598                         ( *iAddRemoveObservers )[ count ]->iObserver != &aObserver ) 

   599                         {

   600                         removeFromServer = EFalse;

   601                         }

   602                     }

   603                 }

   604             break;

   605         case KEventModify:

   606             if ( iModifyObservers )

   607                 {

   608                 for ( count = 0; count < iModifyObservers->Count(); ++count )

   609                     {

   610                     if( removeFromServer && 

   611                         !( *iModifyObservers )[ count ]->iContentID->Compare( aContentID ) &&

   612                         ( *iModifyObservers )[ count ]->iObserver != &aObserver ) 

   613                         {

   614                         removeFromServer = EFalse;

   615                         }

   616                     }

   617                 }

   618             break;

   619         default:

   620             User::Leave(KErrArgument);

   621             break;

   622         }  

   623 

   624 

   625     // Remove the registrations from internal lists and possibly from the server

   626     switch ( aEvent )

   627         {

   628         case KEventAddRemove:

   629             if ( iAddRemoveObservers )

   630                 {

   631                 for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

   632                     {

   633                     if ( ( *iAddRemoveObservers )[ count ]->iObserver == &aObserver &&

   634                          ( *iAddRemoveObservers )[ count ]->iContentID &&

   635                          !( *iAddRemoveObservers )[ count ]->iContentID->Compare( aContentID ) )

   636                         {

   637                         if ( removeFromServer )

   638                             {

   639                             // Unregister the type from the server

   640                             iHandler->UnRegisterFromType(aEvent,(*iAddRemoveObservers)[ count ]->iContentID);

   641                             }

   642 

   643                         // Free Memory

   644                         delete ( *iAddRemoveObservers )[ count ]->iContentID;

   645                         ( *iAddRemoveObservers )[ count ]->iContentID = NULL;

   646                         delete ( *iAddRemoveObservers )[ count ];

   647                         ( *iAddRemoveObservers )[ count ] = NULL;

   648 

   649                         // Delete the element from the table

   650                         iAddRemoveObservers->Delete( count );

   651                         iAddRemoveObservers->Compress();

   652                         return;

   653                         }

   654                     }

   655                 }

   656             User::Leave(KErrNotFound);

   657             break;

   658         case KEventModify:

   659             if ( iModifyObservers )

   660                 {

   661                 for ( count = 0; count < iModifyObservers->Count(); ++count )

   662                     {

   663                     if ( ( *iModifyObservers )[ count ]->iObserver == &aObserver &&

   664                          ( *iModifyObservers )[ count ]->iContentID &&

   665                          !( *iModifyObservers )[ count ]->iContentID->Compare( aContentID ) )

   666                         {

   667 

   668                         if( removeFromServer )

   669                             {

   670                             // Unregister the type from the server

   671                             iHandler->UnRegisterFromType(aEvent,(*iModifyObservers)[ count ]->iContentID);

   672                             }

   673 

   674                         // Free Memory

   675                         delete ( *iModifyObservers )[ count ]->iContentID;

   676                         ( *iModifyObservers )[ count ]->iContentID = NULL;

   677                         delete ( *iModifyObservers )[ count ];

   678                         ( *iModifyObservers )[ count ] = NULL;

   679 

   680                         // Delete the element from the table

   681                         iModifyObservers->Delete( count );

   682                         iModifyObservers->Compress();

   683                         return;

   684                         }

   685                     }

   686                 }

   687             User::Leave(KErrNotFound);

   688             break;

   689         default:

   690             User::Leave(KErrArgument);

   691             break;

   692         }  

   693     // Should never get here

   694     User::Leave( KErrGeneral );

   695     }

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

   697 // CDRMEventHandler::SendEventL

   698 // Sends the event to the client that sends it to the server

   699 // Opens connection if it's not already open

   700 // -----------------------------------------------------------------------------

   701 //

   702 void CDRMEventHandler::SendEventL( MDRMEvent& aEvent, TRequestStatus& aStatus )

   703     {

   704     RMemWriteStream output(iDataBuffer,DRMNotifier::KDRMSizeOfMessage);

   705     CleanupClosePushL( output );

   706     

   707     Mem::FillZ(iDataBuffer,DRMNotifier::KDRMSizeOfMessage);

   708 

   709     if(!iIsOpen)

   710         {

   711 		if(!iHandler)

   712             {

   713             iHandler = new (ELeave) RDRMNotifierClient(iEventType,iEventTypeWait,iData,iWaitData);

   714             }

   715         User::LeaveIfError(iHandler->Connect());

   716         iIsOpen = ETrue;            

   717         }

   718 

   719     aEvent.ExternalizeL(output);

   720     aEvent.GetEventType(*iEventType);

   721     

   722     iHandler->SendEvent(aStatus);

   723     CleanupStack::PopAndDestroy();

   724     };

   725 

   726 // -----------------------------------------------------------------------------

   727 // CDRMEventHandler::CDRMEventHandler

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

   729 // might leave.

   730 // -----------------------------------------------------------------------------

   731 //

   732 CDRMEventHandler::CDRMEventHandler() :

   733    CActive( EPriorityUserInput ), iIsOpen( EFalse )

   734 {

   735    // Nothing

   736 }

   737 

   738 // -----------------------------------------------------------------------------

   739 // CDRMNotificationHandler::ConstructL

   740 // Symbian 2nd phase constructor can leave.

   741 // -----------------------------------------------------------------------------

   742 //

   743 void CDRMEventHandler::ConstructL()

   744 {

   745     iDataBuffer = static_cast<TUint8*>(User::AllocL(DRMNotifier::KDRMSizeOfMessage));

   746     iEventType = static_cast<TDRMEventType*>(User::AllocL(sizeof(TDRMEventType*)));

   747     iWaitDataBuffer = static_cast<TUint8*>(User::AllocL(DRMNotifier::KDRMSizeOfMessage));

   748     iEventTypeWait = static_cast<TDRMEventType*>(User::AllocL(sizeof(TDRMEventType*)));

   749 

   750     iData = new( ELeave ) TPtr8(iDataBuffer,DRMNotifier::KDRMSizeOfMessage,DRMNotifier::KDRMSizeOfMessage);

   751     iWaitData = new( ELeave) TPtr8(iWaitDataBuffer,DRMNotifier::KDRMSizeOfMessage,DRMNotifier::KDRMSizeOfMessage);

   752 

   753     iHandler = new (ELeave) RDRMNotifierClient(iEventType,iEventTypeWait,iData,iWaitData);

   754 

   755     User::LeaveIfError( iHandler->Connect() );

   756     iIsOpen = ETrue;

   757 

   758     iAddRemoveObservers = new( ELeave ) CArrayPtrSeg< TObserverData >( 4 );

   759     iModifyObservers = new( ELeave ) CArrayPtrSeg< TObserverData >( 4 );

   760     iTimeChangeObservers = new( ELeave ) CArrayPtrSeg< TObserverData >( 4 );    

   761     iDelayedObservers = new( ELeave ) CArrayPtrSeg< TDelayedObserverData >( 4 );

   762 

   763     Mem::FillZ(iDataBuffer,DRMNotifier::KDRMSizeOfMessage);

   764     Mem::FillZ(iDataBuffer,DRMNotifier::KDRMSizeOfMessage);

   765     Mem::FillZ(iEventType,sizeof(TDRMEventType));

   766     Mem::FillZ(iEventTypeWait,sizeof(TDRMEventType));

   767 }

   768 

   769 // -----------------------------------------------------------------------------

   770 // CDRMNotificationHandler::RunL

   771 // Inherited from CActive

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

   773 //

   774 void CDRMEventHandler::RunL()

   775 {

   776    __ASSERT_DEBUG( iAddRemoveObservers, User::Invariant() );

   777    __ASSERT_DEBUG( iModifyObservers, User::Invariant() );

   778 

   779    if ( iStatus == KErrCancel )

   780        {

   781        return;

   782        }

   783 

   784    TRAPD( error, HandleRunL() );

   785    

   786    if( error && iIsDelayed )

   787        {

   788        iIsDelayed = EFalse;

   789        }

   790 

   791    // Discard all errors except this one.

   792    if ( error == KErrServerTerminated )

   793    {

   794       User::Leave( KErrServerTerminated );

   795    }  

   796    SetActive();   

   797 }

   798 

   799 void CDRMEventHandler::DoCancel()

   800 {

   801    iHandler->CancelRequest();

   802 }

   803 

   804 // -----------------------------------------------------------------------------

   805 // CDRMEventHandler::GetEventObjectLC

   806 // -----------------------------------------------------------------------------

   807 //

   808 MDRMEvent* CDRMEventHandler::GetEventObjectLC()

   809     {

   810     MDRMEvent* event = NULL;

   811     switch(*iEventTypeWait)

   812         {

   813         case KEventAddRemove:

   814             event = CDRMEventAddRemove::NewLC( ERightsObjectRecieved );

   815             break;

   816         case KEventModify:

   817             event = CDRMEventModify::NewLC();

   818             break;

   819         case KEventTimeChange:

   820             event = CDRMEventTimeChange::NewLC();

   821             break;

   822         }           

   823     return event;

   824     }

   825 

   826 // -----------------------------------------------------------------------------

   827 // CDRMEventHandler::HandleRunL

   828 // -----------------------------------------------------------------------------

   829 //

   830 void CDRMEventHandler::HandleRunL()

   831 {

   832     MDRMEvent* object = NULL;

   833     TDRMEventType event = 0;

   834     TInt count = 0;

   835     HBufC8* contentID = NULL;

   836     TInt error = KErrNone;

   837     

   838     RMemReadStream input(iWaitDataBuffer,DRMNotifier::KDRMSizeOfMessage);

   839     CleanupClosePushL( input );

   840     

   841     if(!iIsOpen)

   842         {

   843 		if(!iHandler)

   844             {

   845             iHandler = new (ELeave) RDRMNotifierClient(iEventType,iEventTypeWait,iData,iWaitData);

   846             }

   847         User::LeaveIfError(iHandler->Connect());

   848         iIsOpen = ETrue;            

   849         }

   850 

   851     object = GetEventObjectLC();

   852     if(!object)

   853         {

   854         User::Leave(KErrGeneral);

   855         }

   856 

   857     object->InternalizeL(input);

   858 

   859     object->GetEventType(event);

   860 

   861     iIsDelayed = ETrue;

   862 

   863     switch ( event )

   864         {

   865         case KEventAddRemove:

   866             if ( iAddRemoveObservers )

   867                 {

   868                 TRAPD( error_mem, contentID = (reinterpret_cast<CDRMEventAddRemove*>(object))->GetContentIDL());

   869                 if ( error_mem )

   870                     {

   871                     iIsDelayed = EFalse;

   872                     User::Leave( error_mem );

   873                     }                

   874                 CleanupStack::PushL(contentID);

   875 

   876                 for ( count = 0; count < iAddRemoveObservers->Count(); ++count )

   877                     {

   878                     if( !( *iAddRemoveObservers )[ count ]->iContentID ||

   879                         !( *iAddRemoveObservers )[ count ]->iContentID->Compare( contentID->Des() ) )

   880                         {

   881                         TRAP( error, ( *iAddRemoveObservers )[ count ]->iObserver->HandleEventL( object ) );

   882                         }

   883                     }

   884                 CleanupStack::PopAndDestroy();

   885                 }

   886             break;

   887         case KEventModify:

   888             if ( iModifyObservers )

   889                 {

   890                 TRAPD(error_mem, contentID = (reinterpret_cast<CDRMEventModify*>(object))->GetContentIDL());

   891                 if( error_mem )

   892                     {

   893                     iIsDelayed = EFalse;

   894                     User::Leave( error_mem );

   895                     }                

   896                 CleanupStack::PushL(contentID);

   897  

   898                 for ( count = 0; count < iModifyObservers->Count(); ++count )

   899                     {

   900                     if( !( *iModifyObservers )[ count ]->iContentID ||

   901                         !( *iModifyObservers )[ count ]->iContentID->Compare( contentID->Des() ) )

   902                         {

   903                         TRAP( error, ( *iModifyObservers )[ count ]->iObserver->HandleEventL( object ) );

   904                         }

   905                     }

   906                 CleanupStack::PopAndDestroy();

   907                 }

   908             break;

   909         case KEventTimeChange:

   910              if ( iTimeChangeObservers )

   911                 {

   912                 for ( count = 0; count < iTimeChangeObservers->Count(); ++count )

   913                     {

   914                     TRAP( error, ( *iTimeChangeObservers )[ count ]->iObserver->HandleEventL( object ) );

   915                     }

   916                 }      

   917             break;

   918         default:

   919             iIsDelayed = EFalse;

   920             User::Leave(KErrArgument);

   921             break;

   922         }

   923         

   924     // Ignore errors   

   925     if( error )

   926         {

   927         // Do nothing

   928         }

   929     if( iStatus != KRequestPending )

   930         {

   931         iStatus = KRequestPending;

   932         iHandler->WaitForCompletion(iStatus);

   933         }

   934     CleanupStack::PopAndDestroy(); // object

   935     CleanupStack::PopAndDestroy(); // input

   936     iIsDelayed = EFalse;

   937 

   938     // Run delayed the adding and removing events in order

   939     while ( iDelayedObservers->Count() )

   940         {

   941         TInt ignore_error = KErrNone;

   942 

   943         switch( ( *iDelayedObservers )[ 0 ]->iRequest )

   944             {

   945             case KRegisterOperation:

   946                 TRAP(ignore_error, 

   947                     RegisterEventObserverL( *( *iDelayedObservers )[ 0 ]->iObserver,

   948                                             ( *iDelayedObservers )[ 0 ]->iEventType ) );

   949                 break;

   950             case KRegisterURIOperation:

   951                 TRAP(ignore_error, 

   952                     RegisterEventObserverL( *( *iDelayedObservers )[ 0 ]->iObserver,

   953                                             ( *iDelayedObservers )[ 0 ]->iEventType,

   954                                             ( *iDelayedObservers )[ 0 ]->iContentID->Des() ) );

   955                 break;

   956             case KUnRegisterOperation:

   957                 TRAP(ignore_error, 

   958                     UnRegisterEventObserverL( *( *iDelayedObservers )[ 0 ]->iObserver,

   959                                               ( *iDelayedObservers )[ 0 ]->iEventType ) );

   960                 break;

   961             case KUnRegisterURIOperation:

   962                 TRAP(ignore_error, 

   963                     UnRegisterEventObserverL( *( *iDelayedObservers )[ 0 ]->iObserver,

   964                                               ( *iDelayedObservers )[ 0 ]->iEventType,

   965                                               ( *iDelayedObservers )[ 0 ]->iContentID->Des() ) );

   966                 break;

   967             default:

   968                 break;

   969             }

   970         if ( ( *iDelayedObservers )[ 0 ]->iContentID )

   971             {

   972             delete ( *iDelayedObservers )[ 0 ]->iContentID;

   973             ( *iDelayedObservers )[ 0 ]->iContentID = NULL;

   974             }

   975         delete ( *iDelayedObservers )[ 0 ];

   976         ( *iDelayedObservers )[ 0 ] = NULL;

   977         iDelayedObservers->Delete( 0 );

   978         iDelayedObservers->Compress();

   979         }

   980     }

   981 

   982 //  End of File