1 /*

     2 * Copyright (c) 2002-2005 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:  Network operations for chat group handling.

    15  *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include "ChatDebugPrint.h"

    20 

    21 #include "CCAGroupManager.h"

    22 

    23 #include "CCAStorageManagerFactory.h"

    24 #include "MCASettings.h"

    25 #include "MCASearchData.h"

    26 #include "MCASearchInterface.h"

    27 #include "MCAStoredGroups.h"

    28 #include "MCAStoredGroup.h"

    29 #include "MCAExtendedStoredGroup.h"

    30 #include "MCAGroupOperations.h"

    31 #include "CCAGroupWrapper.h"

    32 #include "PrivateEngineDefinitions.h"

    33 #include "TStorageManagerGlobals.h"

    34 #include "CCARequest.h"

    35 #include "CCARequestMapper.h"

    36 #include "MCAChatInterface.h"

    37 #include "MCAMessagesWriteInterface.h"

    38 #include "MCAMessageUtils.h"

    39 #include "MCAMessageCreator.h"

    40 #include "ImpsCSPAllErrors.h"

    41 #include "MCAImpsFactory.h"

    42 

    43 #include "CAUtils.h"

    44 #include "camessageutil.h"

    45 

    46 #include <e32keys.h>

    47 #include <ImpsFundamental.h>

    48 #include <ImpsGroupProps.h>

    49 

    50 // for resources

    51 #include <caengineNG.rsg>

    52 #include <stringloader.h>

    53 

    54 // CONSTANTS

    55 const TInt KCCAGMGroupWrappersGranularity = 5;

    56 const TInt KSearchPairsSmallGranularity = 1;

    57 const TInt KMaxUserSearchLimit = 100;

    58 

    59 // indexes to additional data array inside request

    60 const TInt KReqCreateIndexGroupId    = 0;

    61 const TInt KReqCreateIndexScreenName = 2;

    62 const TInt KReqCreateIndexWelcomeMsg = 3;

    63 const TInt KReqCreateIndexGroupTopic = 4;

    64 

    65 const TInt KReqJoinIndexGroupId    = 0;

    66 const TInt KReqJoinIndexScreenName = 1;

    67 

    68 // how many times should we try to generate unique group id

    69 const TInt KMaxGroupIds = 100;

    70 

    71 // maximum groups in search result. If search results

    72 // exceeds this then "too many search results" is shown

    73 const TInt KMaxGroupSearchLimit = 50;

    74 

    75 

    76 // ================= MEMBER FUNCTIONS =======================

    77 

    78 // Symbian OS default constructor can leave.

    79 void CCAGroupManager::ConstructL()

    80     {

    81     iStoredGroups = CCAStorageManagerFactory::GroupListInterfaceL();

    82     }

    83 

    84 // Two-phased constructor.

    85 CCAGroupManager* CCAGroupManager::NewL(

    86     MCASearchInterface& aSearchAPI,

    87     MCASettings& aSettingsAPI,

    88     CCARequestMapper& aRequestMapper,

    89     MCAImpsFactory* aIMPSFactory,

    90     MCAChatInterface& aChatInterface,

    91     MCAMessageUtils& aMessageUtils )

    92     {

    93     CCAGroupManager* self = new ( ELeave ) CCAGroupManager( aSearchAPI,

    94                                                             aSettingsAPI, aRequestMapper, aIMPSFactory,

    95                                                             aChatInterface, aMessageUtils );

    96 

    97     CleanupStack::PushL( self );

    98     self->ConstructL();

    99     CleanupStack::Pop( self );

   100 

   101     return self;

   102     }

   103 

   104 // Destructor

   105 CCAGroupManager::~CCAGroupManager()

   106     {

   107     iGroupWrappers.ResetAndDestroy();

   108     delete iProperties;

   109     delete iPrivProperties;

   110     }

   111 

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

   113 // might leave.

   114 //

   115 CCAGroupManager::CCAGroupManager(

   116     MCASearchInterface& aSearchAPI,

   117     MCASettings& aSettingsAPI,

   118     CCARequestMapper& aRequestMapper,

   119     MCAImpsFactory* aIMPSFactory,

   120     MCAChatInterface& aChatInterface,

   121     MCAMessageUtils& aMessageUtils   )

   122         : iRequestMapper( aRequestMapper ),

   123         iSettingsAPI( aSettingsAPI ),

   124         iSearchAPI( aSearchAPI ),

   125         iImpsFactory( aIMPSFactory ),

   126         iChatInterface( aChatInterface ),

   127         iMessageUtils( aMessageUtils ),

   128         iGroupWrappers( KCCAGMGroupWrappersGranularity )

   129     {

   130     }

   131 

   132 // ---------------------------------------------------------

   133 // CCAGroupManager::PopulateCreatedGroupsL

   134 // ---------------------------------------------------------

   135 //

   136 TInt CCAGroupManager::PopulateCreatedGroupsL( CDesCArray& aGroupList ) const

   137     {

   138     CHAT_DP_FUNC_ENTER( "PopulateCreatedGroupsL" );

   139 

   140     // Reset the given array to be sure that it will be valid

   141     aGroupList.Reset();

   142 

   143     HBufC* loggedUserId = iSettingsAPI.ValueL( MCASettings::EOwnWVUserID );

   144     CleanupStack::PushL( loggedUserId );

   145 

   146     CSearchPairs* pairs =

   147         new ( ELeave ) CSearchPairs( KSearchPairsSmallGranularity );

   148     CleanupStack::PushL( pairs );

   149 

   150     CImpsSearchRequest* request = CImpsSearchRequest::NewL();

   151     CleanupStack::PushL( request );

   152 

   153     request->SetRequestL( EImpsGroupUserIDOwner, *loggedUserId );

   154     pairs->AppendL( request );

   155 

   156     // If there is error in search, return so we don't send stop error request

   157     TInt searchError( KErrNone );

   158     searchError = iSearchAPI.StartSearchL( *pairs, KMaxUserSearchLimit, NULL );

   159     if ( searchError != KErrNone )

   160         {

   161         CHAT_DP( D_CHAT_LIT( "CCAGroupManager::PopulateCreatedGroupsL - error \

   162                               from StartSearchL %d" ), searchError );

   163         // request, pairs, loggedUserId

   164         CleanupStack::PopAndDestroy( 3, loggedUserId );

   165         return searchError;

   166         }

   167 

   168     TInt resultCount( iSearchAPI.SearchDataInterface()->SearchDataCount() );

   169 

   170     // just add all found groups to the group list

   171     for ( TInt counter( 0 ); counter < resultCount; counter++ )

   172         {

   173         TPtrC pGroupId(

   174             iSearchAPI.SearchDataInterface()->SearchData( counter ) );

   175         aGroupList.AppendL( pGroupId );

   176         }

   177 

   178     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::PopulateCreatedGroupsL - found %d \

   179                           groups from joined user" ), aGroupList.Count() );

   180 

   181     CleanupStack::PopAndDestroy( 3, loggedUserId );

   182 

   183     CHAT_DP_FUNC_DONE( "PopulateCreatedGroupsL" );

   184 

   185     return KErrNone;

   186     }

   187 

   188 // ---------------------------------------------------------

   189 // CCAGroupManager::JoinedGroups

   190 // ---------------------------------------------------------

   191 //

   192 TInt CCAGroupManager::JoinedGroups()

   193     {

   194     return iNumJoinedGroups;

   195     }

   196 

   197 

   198 // we just wrap the Handle*L routines by passing them

   199 // on to the correct group wrapper

   200 

   201 // ---------------------------------------------------------

   202 // CCAGroupManager::HandleErrorL

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

   204 //

   205 void CCAGroupManager::HandleErrorL(

   206     TInt aStatus,

   207     TInt aOpId,

   208     const TDesC* /* aDescription */,

   209     const CImpsDetailed* /* aDetailedRes */,

   210     TImpsCspIdentifier& /*aCspId*/ )

   211     {

   212     CHAT_DP_FUNC_ENTER( "HandleErrorL" );

   213     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleErrorL - opid=%d, status=%d" ),

   214              aOpId, aStatus );

   215 

   216     CHAT_DP_FUNC_DONE( "HandleErrorL" );

   217     }

   218 

   219 // ---------------------------------------------------------

   220 // CCAGroupManager::HandleCompleteL()

   221 // ---------------------------------------------------------

   222 //

   223 void CCAGroupManager::HandleCompleteL(

   224     TInt aOpId,

   225     TImpsCspIdentifier& aCspId )

   226     {

   227     CHAT_DP_FUNC_ENTER( "HandleCompleteL" );

   228     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleCompleteL - opid=%d" ), aOpId );

   229 

   230     CCAGroupWrapper* wrapper = FindGroupWrapper( aOpId );

   231 

   232     if ( ! wrapper )

   233         {

   234         // no such wrapper

   235         CHAT_DP_FUNC_DP( "HandleCompleteL", "No wrapper, leaving" );

   236         User::Leave( KErrNotFound );

   237         }

   238 

   239     CCARequest* request = wrapper->Request();

   240     __ASSERT_DEBUG( request, User::Panic( KCAEnginePanicCategory,

   241                                           KErrNotFound ) );

   242     if ( !request )

   243         {

   244         User::Leave( KErrNotFound );

   245         }

   246     const MDesCArray* dataArray = request->AdditionalData();

   247 

   248     switch ( request->RequestType() )

   249         {

   250         case ECreateAndJoinGroup :

   251             {

   252             __ASSERT_DEBUG( dataArray, User::Panic( KCAEnginePanicCategory,

   253                                                     KErrNotFound ) );

   254             if ( !dataArray )

   255                 {

   256                 // can't use User::LeaveIfNull for const pointers

   257                 User::Leave( KErrGeneral );

   258                 }

   259 

   260             CHAT_DP_FUNC_DP( "HandleCompleteL", "Creating chat data for group" );

   261 

   262             MCAMessagesWriteInterface& groupChat =

   263                 iChatInterface.MessageWriteInterfaceL( KNullDesC, KNullDesC,

   264                                                        dataArray->MdcaPoint( KReqCreateIndexGroupId ),

   265                                                        MCAMessagesReadInterface::EGroupContainer );

   266 

   267             groupChat.SetScreenNameL( dataArray->MdcaPoint(

   268                                           KReqCreateIndexScreenName ) );

   269 

   270             // Write welcome message to chat

   271             TPtrC welcome = dataArray->MdcaPoint( KReqCreateIndexWelcomeMsg );

   272             TPtrC topic = dataArray->MdcaPoint( KReqCreateIndexGroupTopic );

   273 

   274             CHAT_DP_FUNC_DP( "HandleCompleteL", "Showing welcome message" );

   275             MCAStoredGroup& group = wrapper->Group();

   276             TPtrC groupIdentifier =

   277                 group.GroupName().Length() > 0 ? group.GroupName() :

   278                 CAUtils::DisplayId( group.GroupId() );

   279 

   280             WriteWelcomeMessageL( welcome, groupIdentifier, topic, groupChat );

   281 

   282             // note, it suffices to increase the number of created groups

   283             // when CreateGroupL is called

   284             break;

   285             }

   286 

   287         default:

   288             {

   289             break;

   290             }

   291 

   292         }

   293 

   294     wrapper->HandleCompleteL( aOpId, aCspId );

   295 

   296     CHAT_DP_FUNC_DONE( "HandleCompleteL" );

   297     }

   298 

   299 // ---------------------------------------------------------

   300 // CCAGroupManager::HandleJoinL()

   301 // ---------------------------------------------------------

   302 //

   303 void CCAGroupManager::HandleJoinL(

   304     TInt aOpId,

   305     const MDesCArray& aUserList,

   306     const MDesCArray& aScreenNames,

   307     const TDesC& aWelcomeText,

   308     TImpsCspIdentifier& aCspId )

   309     {

   310     CHAT_DP_FUNC_ENTER( "HandleJoinL" );

   311     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleJoinL - opid=%d" ), aOpId );

   312 

   313     CCAGroupWrapper* wrapper = FindGroupWrapper( aOpId );

   314 

   315     if ( ! wrapper )

   316         {

   317         // no wrapper

   318         CHAT_DP_FUNC_DP( "HandleJoinL", "No wrapper, leaving" );

   319         User::Leave( KErrNotFound );

   320         }

   321 

   322     CCARequest* request = wrapper->Request();

   323     __ASSERT_DEBUG( request, User::Panic( KCAEnginePanicCategory,

   324                                           KErrNotFound ) );

   325     if ( !request )

   326         {

   327         User::Leave( KErrNotFound );

   328         }

   329     const MDesCArray* dataArray = request->AdditionalData();

   330 

   331     __ASSERT_DEBUG( dataArray, User::Panic( KCAEnginePanicCategory,

   332                                             KErrNotFound ) );

   333     if ( !dataArray )

   334         {

   335         // can't use User::LeaveIfError for const pointers

   336         User::Leave( KErrGeneral );

   337         }

   338 

   339     CHAT_DP_FUNC_DP( "HandleJoinL", "Creating chat data for group" );

   340 

   341     MCAMessagesWriteInterface& groupChat =

   342         iChatInterface.MessageWriteInterfaceL( KNullDesC, KNullDesC,

   343                                                dataArray->MdcaPoint( KReqJoinIndexGroupId ),

   344                                                MCAMessagesReadInterface::EGroupContainer );

   345     groupChat.SetScreenNameL( dataArray->MdcaPoint( KReqJoinIndexScreenName ) );

   346 

   347 

   348     CImpsCommonGroupProps* commonProps = NULL;

   349     CImpsPrivateGroupProps* privProps = NULL;

   350     // ownership is preserved in wrapper

   351     wrapper->LocalProperties( commonProps, privProps );

   352 

   353     TPtrC topic( KNullDesC );

   354     if ( commonProps )

   355         {

   356         topic.Set( commonProps->Topic() );

   357         }

   358 

   359     // Show welcome message

   360     MCAStoredGroup& group = wrapper->Group();

   361     TPtrC groupIdentifier =

   362         group.GroupName().Length() > 0 ? group.GroupName() :

   363         CAUtils::DisplayId( group.GroupId() );

   364     TRAPD( err, WriteWelcomeMessageL( aWelcomeText, groupIdentifier, topic, groupChat ) );

   365     if ( err == KErrNoMemory )

   366         {

   367         // Handle no memory error here

   368         request->SetErrorCode( err );

   369         request->StopWaitIfNeeded();

   370         return;

   371         }

   372     else

   373         {

   374         User::LeaveIfError( err );

   375         }

   376 

   377     // Topic was shown in WriteWelcomeMessageL

   378     if ( topic.Length() > 0 )

   379         {

   380         wrapper->SetTopicShown( ETrue );

   381         }

   382 

   383     // make sure it's marked as joined in the UI

   384     MCAExtendedStoredGroup& grp =

   385         static_cast<MCAExtendedStoredGroup&>( wrapper->Group() );

   386     if ( !grp.IsJoined() )

   387         {

   388         grp.SetJoined( ETrue );

   389         iNumJoinedGroups++;

   390         }

   391 

   392     CHAT_DP_FUNC_DP( "HandleJoinL", "Passing on to wrapper" );

   393     wrapper->HandleJoinL( aOpId, aUserList, aScreenNames,

   394                           aWelcomeText, aCspId );

   395 

   396     // show the joined-messages

   397     TInt numNames = aScreenNames.MdcaCount();

   398     for ( TInt index = 0; index < numNames; index++ )

   399         {

   400         HBufC* newUser = aScreenNames.MdcaPoint( index ).AllocLC();

   401 

   402         HBufC* finalNewUserText =

   403             StringLoader::LoadLC( R_SYSTEM_MESSAGE_JOIN,

   404                                   *newUser );

   405 

   406         CHAT_DP_FUNC_DP( "HandleJoinL", "Initiating new users message" );

   407 

   408         MCAMessage* newUserMsg =

   409             iMessageUtils.MessageCreator().CreateSystemMessageL(

   410                 MCAMessage::ESystemMessageNewUsers,

   411                 *finalNewUserText );

   412 

   413         // Append message

   414         TRAPD( err, CAMessageUtil::AppendMessageWithDateStampL(

   415                    *newUserMsg,

   416                    groupChat,

   417                    iMessageUtils.MessageCreator() ) );

   418 

   419         if ( err == KErrNoMemory )

   420             {

   421             // Handle no memory error here

   422             CleanupStack::PopAndDestroy( 2, newUser ); // finalNewUserText, newUser

   423             request->SetErrorCode( err );

   424             request->StopWaitIfNeeded();

   425             return;

   426             }

   427         else

   428             {

   429             User::LeaveIfError( err );

   430             }

   431 

   432         CleanupStack::PopAndDestroy( 2, newUser ); // finalNewUserText, newUser

   433         }

   434 

   435     CHAT_DP_FUNC_DONE( "HandleJoinL" );

   436     }

   437 

   438 // ---------------------------------------------------------

   439 // CCAGroupManager::HandleGroupMembersL()

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

   441 //

   442 void CCAGroupManager::HandleGroupMembersL(

   443     TInt aOpId,

   444     const MDesCArray& aUserList,

   445     const MDesCArray& aScreenNames,

   446     const MDesCArray& aModers,

   447     const MDesCArray& aAdmins,

   448     TImpsCspIdentifier& aCspId )

   449     {

   450     CHAT_DP_FUNC_ENTER( "HandleGroupMembersL" );

   451     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleGroupMembersL - opid=%d" ),

   452              aOpId );

   453 

   454     CCAGroupWrapper* wrapper = FindGroupWrapper( aOpId );

   455     if ( ! wrapper )

   456         {

   457         CHAT_DP_FUNC_DP( "HandleGroupMembersL", "No wrapper, leaving" );

   458         User::Leave( KErrNotFound );

   459         }

   460 

   461     CHAT_DP_FUNC_DP( "HandleGroupMembersL", "Passing on to wrapper" );

   462     wrapper->HandleGroupMembersL( aOpId, aUserList, aScreenNames, aModers,

   463                                   aAdmins, aCspId );

   464 

   465     CHAT_DP_FUNC_DONE( "HandleGroupMembersL" );

   466     }

   467 

   468 // ---------------------------------------------------------

   469 // CCAGroupManager::HandleGroupPropertiesL()

   470 // ---------------------------------------------------------

   471 //

   472 void CCAGroupManager::HandleGroupPropertiesL(

   473     TInt aOpId,

   474     const TDesC& aGroupId,

   475     const CImpsCommonGroupProps& aGroupProps,

   476     const CImpsPrivateGroupProps& aOwnProps,

   477     TImpsCspIdentifier& aCspId )

   478     {

   479     CHAT_DP_FUNC_ENTER( "HandleGroupPropertiesL" );

   480     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleGroupPropertiesL - opid=%d" ),

   481              aOpId );

   482 

   483     CCAGroupWrapper* wrapper = NULL;

   484     TPtrC groupId( aGroupId );

   485 

   486     if ( aOpId != 0 )

   487         {

   488         // aGroupId is empty

   489         wrapper = FindGroupWrapper( aOpId );

   490 

   491         if ( !wrapper )

   492             {

   493             CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "No wrapper, leaving" );

   494             User::Leave( KErrNotFound );

   495             }

   496 

   497         groupId.Set( wrapper->Group().GroupId() );

   498         }

   499     else

   500         {

   501         // aGroupId is valid

   502         wrapper = FindGroupWrapper( aGroupId );

   503         }

   504 

   505     if ( ! wrapper )

   506         {

   507         CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "No wrapper, leaving" );

   508         User::Leave( KErrNotFound );

   509         }

   510 

   511     CImpsCommonGroupProps* common = NULL;

   512     CImpsPrivateGroupProps* priv = NULL;

   513 

   514     // does the wrapper have the properties already?

   515     wrapper->LocalProperties( common, priv );

   516 

   517     if ( ( !common ) && ( !priv ) )

   518         {

   519         CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "No existing properties" );

   520 

   521         // no existing properties, so create new ones

   522         common = CImpsCommonGroupProps::NewL();

   523         CleanupStack::PushL( common );

   524 

   525         priv = CImpsPrivateGroupProps::NewL();

   526         CleanupStack::Pop( common );

   527 

   528         CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "Created new properties" );

   529 

   530         // transfer ownership

   531         CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "Setting the properties" );

   532         wrapper->SetLocalProperties( common, priv );

   533         }

   534 

   535     // set the admin status

   536     CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "Setting administrator status" );

   537     MCAExtendedStoredGroup& group =

   538         static_cast<MCAExtendedStoredGroup&>( wrapper->Group() );

   539 

   540     if ( aOwnProps.Privileges() == EImpsAdmin )

   541         {

   542         CHAT_DP_FUNC_DP( "HandleGroupPropertiesL",

   543                          "User is administrator in group" );

   544         group.SetAdmin( ETrue );

   545         }

   546     else if ( aOwnProps.Privileges() != EImpsUserUndef )

   547         {

   548         CHAT_DP_FUNC_DP( "HandleGroupPropertiesL",

   549                          "User is not administrator in group" );

   550         group.SetAdmin( EFalse );

   551         }

   552 

   553     if ( aGroupProps.GroupName().Length() > 0 )

   554         {

   555         if ( aGroupProps.GroupName().CompareC( group.GroupName() ) != 0 )

   556             {

   557             // group name has changed, so update it and signal UI

   558             group.SetGroupNameL( aGroupProps.GroupName() );

   559             iStoredGroups->SignalGroupChangedL( group.GroupId() );

   560             }

   561         }

   562     // if the group is stored in persistent storage, save changes to disk also

   563     if ( group.StorageType() == TStorageManagerGlobals::EStoragePersistent )

   564         {

   565         group.SaveChangesL();

   566         }

   567 

   568 

   569     // see if anything changed

   570     MCAMessagesWriteInterface& groupChat =

   571         iChatInterface.MessageWriteInterfaceL( KNullDesC, KNullDesC, groupId );

   572 

   573     // Ignore empty topics. We must only react to push messages

   574     // React also when topic was not shown in HandleJoinL while joining

   575     if ( ( ( aOpId == 0 ) && ( aGroupProps.Topic().Length() > 0 ) )

   576          || ( !( wrapper->IsTopicShown() ) && ( aOpId == iPropsOpIdWhileJoining ) ) )

   577         {

   578         // there is a topic, but has it changed?

   579 

   580         if ( ( ( 0 != aGroupProps.Topic().CompareC( common->Topic() ) ) ||

   581                !( wrapper->IsTopicShown() ) // Topic changed by user, compare gives 0

   582              )

   583              && aOpId == 0 )

   584             {

   585             // Check the group topic again, if length > 0, then display the topic

   586             if ( aGroupProps.Topic().Length() > 0 )

   587                 {

   588                 // it has changed

   589                 CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "Topic has changed" );

   590 

   591                 // Topic has changed so initiate system message

   592                 HBufC* newTopic = aGroupProps.Topic().AllocLC();

   593 

   594                 HBufC* finalNewTopic =

   595                     StringLoader::LoadLC( R_SYSTEM_MESSAGE_TOPIC,

   596                                           *newTopic );

   597 

   598                 MCAMessage* topicChgMsg =

   599                     iMessageUtils.MessageCreator().CreateSystemMessageL(

   600                         MCAMessage::ESystemMessageTopicChanged,

   601                         *finalNewTopic );

   602 

   603                 // Append message

   604                 CAMessageUtil::AppendMessageWithDateStampL(

   605                     *topicChgMsg,

   606                     groupChat,

   607                     iMessageUtils.MessageCreator() );

   608 

   609                 wrapper->SetTopicShown( ETrue );

   610 

   611                 CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleGroupPropertiesL - \

   612                                   topic is %S" ), finalNewTopic );

   613 

   614                 CleanupStack::PopAndDestroy( 2, newTopic );//finalNewTopic, newTopic

   615                 }

   616             }

   617         else if ( aGroupProps.Topic().Length() > 0

   618                   && aOpId == iPropsOpIdWhileJoining )

   619             {

   620             // Show topic of group when joining

   621             iPropsOpIdWhileJoining = KErrNotFound;

   622             HBufC* topicText =

   623                 StringLoader::LoadLC( R_SYSTEM_MESSAGE_TOPIC_TEXT,

   624                                       aGroupProps.Topic() );

   625             groupChat.AppendL(

   626                 iMessageUtils.MessageCreator().CreateSystemMessageL(

   627                     MCAMessage::ESystemMessageWelcome, *topicText ) );

   628 

   629             wrapper->SetTopicShown( ETrue );

   630             CleanupStack::PopAndDestroy( topicText );

   631             }

   632         }

   633 

   634     // Private (whispering) state change. We must only react to push messages

   635     if ( ( aOpId == 0 ) && ( aGroupProps.IsPrivateAllowed() == EImpsPropYes ) )

   636         {

   637         // The state is active, but has it changed?

   638         if ( aGroupProps.IsPrivateAllowed() != common->IsPrivateAllowed() )

   639             {

   640             // private flag has changed

   641             CHAT_DP_FUNC_DP( "HandleGroupPropertiesL",

   642                              "Private messaging turn on" );

   643             HBufC* privatMessaging =

   644                 StringLoader::LoadLC( R_SYSTEM_MESSAGE_PRIVAT_ON );

   645 

   646             MCAMessage* privateChgMsg =

   647                 iMessageUtils.MessageCreator().CreateSystemMessageL(

   648                     MCAMessage::ESystemMessagePrivatChanged,

   649                     *privatMessaging );

   650 

   651             // Append message

   652             CAMessageUtil::AppendMessageWithDateStampL(

   653                 *privateChgMsg,

   654                 groupChat,

   655                 iMessageUtils.MessageCreator() );

   656 

   657             CleanupStack::PopAndDestroy( privatMessaging );

   658             }

   659         }

   660     else

   661         {

   662         // we must only react to push messages

   663         if ( ( aOpId == 0 ) &&

   664              ( aGroupProps.IsPrivateAllowed() != EImpsPropUndef ) )

   665             {

   666             // the flag is in some non-empty, valid, non-Yes state

   667             // (currently only one such possibility)

   668 

   669             if ( aGroupProps.IsPrivateAllowed() != common->IsPrivateAllowed() )

   670                 {

   671                 CHAT_DP_FUNC_DP( "HandleGroupPropertiesL",

   672                                  "Private messaging turn off" );

   673 

   674                 HBufC* privatMessaging = StringLoader::LoadLC(

   675                                              R_SYSTEM_MESSAGE_PRIVAT_OFF );

   676 

   677                 MCAMessage* privateChgMsg =

   678                     iMessageUtils.MessageCreator().CreateSystemMessageL(

   679                         MCAMessage::ESystemMessagePrivatChanged,

   680                         *privatMessaging );

   681 

   682                 // Append message

   683                 CAMessageUtil::AppendMessageWithDateStampL(

   684                     *privateChgMsg,

   685                     groupChat,

   686                     iMessageUtils.MessageCreator() );

   687 

   688                 CleanupStack::PopAndDestroy( privatMessaging );

   689                 }

   690             }

   691         }

   692 

   693     CHAT_DP_FUNC_DP( "HandleGroupPropertiesL", "Passing on to wrapper" );

   694     wrapper->HandleGroupPropertiesL( aOpId, groupId, aGroupProps,

   695                                      aOwnProps, aCspId );

   696 

   697     CHAT_DP_FUNC_DONE( "HandleGroupPropertiesL" );

   698     }

   699 

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

   701 // CCAGroupManager::HandleRejectListL()

   702 // ---------------------------------------------------------

   703 //

   704 void CCAGroupManager::HandleRejectListL(

   705     TInt aOpId,

   706     const MDesCArray& aUserList,

   707     TImpsCspIdentifier& aCspId )

   708     {

   709     CHAT_DP_FUNC_ENTER( "HandleRejectListL" );

   710     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleRejectListL - opid=%d" ),

   711              aOpId );

   712 

   713     CCAGroupWrapper* wrapper = FindGroupWrapper( aOpId );

   714     if ( ! wrapper )

   715         {

   716         CHAT_DP_FUNC_DP( "HandleRejectListL", "No wrapper, leaving" );

   717         User::Leave( KErrNotFound );

   718         }

   719 

   720     CHAT_DP_FUNC_DP( "HandleRejectListL", "Passing on to wrapper" );

   721     wrapper->HandleRejectListL( aOpId, aUserList, aCspId );

   722 

   723     CHAT_DP_FUNC_DONE( "HandleRejectListL" );

   724     }

   725 

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

   727 // CCAGroupManager::HandleSubscriptionL()

   728 // ---------------------------------------------------------

   729 //

   730 void CCAGroupManager::HandleSubscriptionL(

   731     TInt aOpId,

   732     TBool aIsSubscribed,

   733     TImpsCspIdentifier& aCspId )

   734     {

   735     CHAT_DP_FUNC_ENTER( "HandleSubscriptionL" );

   736     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleSubscriptionL - opid=%d" ),

   737              aOpId );

   738 

   739     // can't be a push message

   740     CCAGroupWrapper* wrapper = FindGroupWrapper( aOpId );

   741     if ( ! wrapper )

   742         {

   743         CHAT_DP_FUNC_DP( "HandleSubscriptionL", "No wrapper, leaving" );

   744         User::Leave( KErrNotFound );

   745         }

   746 

   747     CHAT_DP_FUNC_DP( "HandleSubscriptionL", "Passing on to wrapper" );

   748     wrapper->HandleSubscriptionL( aOpId, aIsSubscribed, aCspId );

   749 

   750     CHAT_DP_FUNC_DONE( "HandleSubscriptionL" );

   751     }

   752 

   753 // ---------------------------------------------------------

   754 // CCAGroupManager::HandleNewUsersL()

   755 // ---------------------------------------------------------

   756 //

   757 void CCAGroupManager::HandleNewUsersL(

   758     const TDesC& aGroupId,

   759     const MDesCArray& aUserList,

   760     const MDesCArray& aScreenNames,

   761     TImpsCspIdentifier& aCspId )

   762     {

   763     CHAT_DP_FUNC_ENTER( "HandleNewUsersL" );

   764     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleNewUsersL " ) );

   765 

   766     CCAGroupWrapper* wrapper = FindGroupWrapper( aGroupId );

   767 

   768     if ( ! wrapper )

   769         {

   770         CHAT_DP_FUNC_DP( "HandleNewUsersL", "No wrapper, leaving" );

   771         User::Leave( KErrNotFound );

   772         }

   773 

   774     // print the user and screen names list

   775 #ifdef _DEBUG

   776     TInt i( 0 );

   777     TInt count( aUserList.MdcaCount() );

   778     CHAT_DP_FUNC_DP( "HandleNewUsersL", "User list:" );

   779     for ( i = 0; i < count; i++ )

   780         {

   781         TPtrC p = TPtrC( aUserList.MdcaPoint( i ) );

   782         CHAT_DP( D_CHAT_LIT( "   %S" ), &p );

   783         }

   784 

   785     count = aScreenNames.MdcaCount();

   786     CHAT_DP_FUNC_DP( "HandleNewUsersL", "Screen names list:" );

   787     for ( i = 0; i < count; i++ )

   788         {

   789         TPtrC p = TPtrC( aScreenNames.MdcaPoint( i ) );

   790         CHAT_DP( D_CHAT_LIT( "   %S" ), &p );

   791         }

   792 #endif

   793 

   794     // get the list of participants

   795     MCAStoredGroup& group = wrapper->Group();

   796 

   797     // this granularity is as good as any

   798     CDesCArrayFlat* participants =

   799         new ( ELeave ) CDesCArrayFlat( KJoinedMembersArrayGranularity );

   800     CleanupStack::PushL( participants );

   801     group.GetParticipantsL( *participants );

   802 

   803     TInt numNames( aScreenNames.MdcaCount() );

   804 

   805     // list has names

   806     for ( TInt index = 0; index < numNames; index++ )

   807         {

   808         // don't show joined-message for persons already joined to the group

   809         TInt posIgnored = 0;

   810         if ( participants->Find( aScreenNames.MdcaPoint( index ),

   811                                  posIgnored, ECmpFolded ) )

   812             {

   813             // a new user, show the message

   814             HBufC* newUser = aScreenNames.MdcaPoint( index ).AllocLC();

   815 

   816             HBufC* finalNewUserText =

   817                 StringLoader::LoadLC( R_SYSTEM_MESSAGE_JOIN,

   818                                       *newUser );

   819 

   820             CHAT_DP_FUNC_DP( "HandleNewUsersL",

   821                              "Initiating new users message" );

   822 

   823             MCAMessagesWriteInterface& groupChat =

   824                 iChatInterface.MessageWriteInterfaceL( KNullDesC,

   825                                                        KNullDesC, aGroupId );

   826 

   827             MCAMessage* newUserMsg =

   828                 iMessageUtils.MessageCreator().CreateSystemMessageL(

   829                     MCAMessage::ESystemMessageNewUsers,

   830                     *finalNewUserText );

   831 

   832             // Append message

   833             CAMessageUtil::AppendMessageWithDateStampL(

   834                 *newUserMsg,

   835                 groupChat,

   836                 iMessageUtils.MessageCreator() );

   837 

   838             // finalNewUserText, newUser

   839             CleanupStack::PopAndDestroy( 2, newUser );

   840             }

   841         }

   842 

   843     CleanupStack::PopAndDestroy( participants );

   844 

   845     CHAT_DP_FUNC_DP( "HandleNewUsersL", "Passing on to wrapper" );

   846     wrapper->HandleNewUsersL( aGroupId, aUserList, aScreenNames, aCspId );

   847 

   848     CHAT_DP_FUNC_DONE( "HandleNewUsersL" );

   849     }

   850 

   851 // ---------------------------------------------------------

   852 // CCAGroupManager::HandleLeftUsersL()

   853 // ---------------------------------------------------------

   854 //

   855 void CCAGroupManager::HandleLeftUsersL(

   856     const TDesC& aGroupId,

   857     const MDesCArray& aUserList,

   858     const MDesCArray& aScreenNames,

   859     TImpsCspIdentifier& aCspId )

   860     {

   861     CHAT_DP_FUNC_ENTER( "HandleLeftUsersL" );

   862     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleLeftUsersL" ) );

   863 

   864     CCAGroupWrapper* wrapper = FindGroupWrapper( aGroupId );

   865 

   866     if ( ! wrapper )

   867         {

   868         CHAT_DP_FUNC_DP( "HandleLeftUsersL", "No wrapper, leaving" );

   869         User::Leave( KErrNotFound );

   870         }

   871 

   872     CHAT_DP_FUNC_DP( "HandleLeftUsersL", "Passing on to wrapper" );

   873     wrapper->HandleLeftUsersL( aGroupId, aUserList, aScreenNames, aCspId );

   874 

   875     TInt numNames( aScreenNames.MdcaCount() );

   876     // list has names

   877     for ( TInt index = 0; index < numNames; index++ )

   878         {

   879         HBufC* leftUser = aScreenNames.MdcaPoint( index ).AllocLC();

   880 

   881         HBufC* finalLeftUserText =

   882             StringLoader::LoadLC( R_SYSTEM_MESSAGE_LEAVE,

   883                                   *leftUser );

   884 

   885         CHAT_DP_FUNC_DP( "HandleLeftUsersL", "Initiating left users message" );

   886 

   887         MCAMessagesWriteInterface& groupChat =

   888             iChatInterface.MessageWriteInterfaceL( KNullDesC,

   889                                                    KNullDesC, aGroupId );

   890 

   891         MCAMessage* userLeftMsg =

   892             iMessageUtils.MessageCreator().CreateSystemMessageL(

   893                 MCAMessage::ESystemMessageLeftUsers, *finalLeftUserText );

   894 

   895         // Append message

   896         CAMessageUtil::AppendMessageWithDateStampL(

   897             *userLeftMsg,

   898             groupChat,

   899             iMessageUtils.MessageCreator() );

   900 

   901         CleanupStack::PopAndDestroy( 2, leftUser ); // finalLeftUserText, leftUser

   902         }

   903 

   904     CHAT_DP_FUNC_DONE( "HandleLeftUsersL" );

   905     }

   906 

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

   908 // CCAGroupManager::HandleLeaveL()

   909 // ---------------------------------------------------------

   910 //

   911 void CCAGroupManager::HandleLeaveL(

   912     TInt aOpId,

   913     const TDesC& aGroupId,

   914     const TDesC& aDescription,

   915     TImpsCspIdentifier& aCspId )

   916     {

   917     CHAT_DP_FUNC_ENTER( "HandleLeaveL" );

   918     CHAT_DP( D_CHAT_LIT( "CCAGroupManager::HandleLeaveL - opid=%d" ), aOpId );

   919 

   920     CCAGroupWrapper* wrapper = NULL;

   921     if ( aOpId != 0 )

   922         {

   923         // operation id is valid

   924         wrapper = FindGroupWrapper( aOpId );

   925         }

   926     else

   927         {

   928         // group id is valid

   929         wrapper = FindGroupWrapper( aGroupId );

   930         }

   931 

   932     if ( ! wrapper )

   933         {

   934         CHAT_DP_FUNC_DP( "HandleLeaveL", "No wrapper, leaving" );

   935         User::Leave( KErrNotFound );

   936         }

   937 

   938     // handle the leave in wrapper

   939     MCAExtendedStoredGroup& gr =

   940         static_cast<MCAExtendedStoredGroup&>( wrapper->Group() );

   941 

   942     // Work with copy of group id, as wrapper gets deleted soon.

   943     // Also, group id is not valid in push.

   944     HBufC* grId = gr.GroupId().AllocLC();

   945 

   946     CHAT_DP_FUNC_DP( "HandleLeaveL", "Passing on to wrapper" );

   947 

   948     wrapper->LastImpsError( iLastImpsError );

   949     //reset/consume last error

   950     iLastImpsError = KErrNone;

   951 

   952     wrapper->HandleLeaveL( aOpId, *grId, aDescription, aCspId );

   953 

   954     if ( aOpId == 0 )

   955         {

   956         CHAT_DP_FUNC_DP( "HandleLeaveL",

   957                          "Push message, cleaning up in HandleLeaveL" );

   958         // push messages we cleanup here,

   959         // pull messages in the LeaveGroupL which originated

   960         // this call chain

   961         CleanupLeaveGroupL( *grId );

   962         }

   963 

   964     CleanupStack::PopAndDestroy( grId );

   965     CHAT_DP_FUNC_DONE( "HandleLeaveL" );

   966     }

   967 

   968 // set group as un-joined, and delete wrapper, group and associated

   969 // group chat data

   970 void CCAGroupManager::CleanupLeaveGroupL( const TDesC& aGroupId )

   971     {

   972     CHAT_DP_FUNC_ENTER( "CleanupLeaveGroupL" );

   973 

   974     CCAGroupWrapper* wrapper = FindGroupWrapper( aGroupId );

   975     if ( !wrapper )

   976         {

   977         CHAT_DP_FUNC_DP( "CleanupLeaveGroupL", "no wrapper, nothing to do!" );

   978         return;

   979         }

   980     MCAExtendedStoredGroup& gr =

   981         static_cast<MCAExtendedStoredGroup&>( wrapper->Group() );

   982 

   983     CHAT_DP_FUNC_DP( "CleanupLeaveGroupL", "Leaving group" );

   984 

   985     if ( gr.IsJoined() )

   986         {

   987         gr.SetJoined( EFalse );

   988         iNumJoinedGroups--;

   989         }

   990 

   991     if ( ( !gr.IsOwnGroup() ) &&

   992          ( gr.StorageType() != TStorageManagerGlobals::EStoragePersistent ) )

   993         {

   994         // not own, not stored and not joined (after CleanupLeaveGroupL)

   995         // aWrappers shouldn't be on the list, so delete also from storage

   996         // (not from server)

   997         CHAT_DP_FUNC_DP( "CleanupLeaveGroupL", "Deleting aWrapper and group" );

   998         // delete returns error code of network delete operation

   999         // in case of group leave it is not import if group deleting fails

  1000         // from server, return code ignored

  1001         DeleteGroupL( aGroupId, EFalse );

  1002         }

  1003     else

  1004         {

  1005         // delete all server-related things:

  1006         // members, participants, admin status, whispering, etc.

  1007         gr.ResetMembersLocally();

  1008         gr.ResetParticipantsL();

  1009 

  1010         gr.SetAdmin( EFalse );

  1011 

  1012         // delete wrapper

  1013         DeleteGroupWrapper( aGroupId );

  1014         RemoveChatDataL( aGroupId );

  1015         }

  1016 

  1017     CHAT_DP_FUNC_DONE( "CleanupLeaveGroupL" );

  1018     }

  1019 

  1020 

  1021 

  1022 // ---------------------------------------------------------

  1023 // CCAGroupManager::NumberOfCreatedGroupsDuringSession

  1024 // ---------------------------------------------------------

  1025 //

  1026 TInt CCAGroupManager::NumberOfCreatedGroupsDuringSession() const

  1027     {

  1028     return iNumCreatedGroups;

  1029     }

  1030 

  1031 // ---------------------------------------------------------

  1032 // CCAGroupManager::GroupOperations

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

  1034 //

  1035 MCAGroupOperations* CCAGroupManager::GroupOperationsL( const TDesC& aId )

  1036     {

  1037     CHAT_DP_FUNC_ENTER( "GroupOperationsL" );

  1038 

  1039     CCAGroupWrapper* groupWrapper = FindGroupWrapper( aId );

  1040     if ( groupWrapper )

  1041         {

  1042         // found an existing wrapper

  1043         CHAT_DP_FUNC_DONE( "GroupOperationsL" );

  1044         return groupWrapper;

  1045         }

  1046 

  1047     CHAT_DP_FUNC_DONE( "GroupOperationsL" );

  1048 

  1049     // no existing wrapper. make a new one, store it and return it

  1050     return CreateWrapperL( aId );

  1051     }

  1052 

  1053 // ---------------------------------------------------------

  1054 // CCAGroupManager::SetGroupEventObserver

  1055 // Call with NULL observer is safely handled at all times

  1056 // ---------------------------------------------------------

  1057 //

  1058 void CCAGroupManager::SetGroupEventObserverL( const TDesC& aId,

  1059                                               MCAGroupEventObserver* aObserver )

  1060     {

  1061     CHAT_DP_FUNC_ENTER( "SetGroupEventObserverL" );

  1062 

  1063     CCAGroupWrapper* groupWrapper = FindGroupWrapper( aId );

  1064 

  1065     if ( ! groupWrapper )

  1066         {

  1067         // not found

  1068         if ( aObserver )

  1069             {

  1070             // valid observer

  1071             CHAT_DP_FUNC_DP( "SetGroupEventObserverL", "Creating new wrapper" );

  1072             groupWrapper = CreateWrapperL( aId );

  1073             }

  1074         }

  1075 

  1076     if ( groupWrapper )

  1077         {

  1078         // no new wrappers are to be created for null observers - in

  1079         // such a case there's no observer anyway!

  1080         CHAT_DP_FUNC_DP( "SetGroupEventObserverL", "Setting event observer" );

  1081         groupWrapper->RegisterEventObserver( aObserver );

  1082         }

  1083 

  1084     CHAT_DP_FUNC_DONE( "SetGroupEventObserverL" );

  1085     }

  1086 

  1087 // ---------------------------------------------------------

  1088 // CCAGroupManager::CreateGroupL

  1089 // ---------------------------------------------------------

  1090 //

  1091 HBufC* CCAGroupManager::CreateGroupL(

  1092     CImpsCommonGroupProps* aProperties,

  1093     CImpsPrivateGroupProps* aPrivProperties,

  1094     const TDesC& aScreenName,

  1095     TBool aJoinGroup,

  1096     TBool aIsWhisperingEnabled,

  1097     TInt& aErrorCode

  1098 )

  1099     {

  1100     CHAT_DP_FUNC_ENTER( "CreateGroupL" );

  1101 

  1102     if ( !aProperties || !aPrivProperties )

  1103         {

  1104         User::Leave( KErrArgument );

  1105         }

  1106     // 1. create group to storage

  1107     // 2. invent a group name for the newly created group

  1108     // 3. create a group wrapper

  1109     // 4. pass this method on to the group wrapper

  1110     // 5. return the group id

  1111 

  1112 

  1113     // deleting old values, just in case that previous CreateGroup has failed

  1114     delete iProperties;

  1115     delete iPrivProperties;

  1116     iProperties = aProperties;

  1117     iPrivProperties = aPrivProperties;

  1118 

  1119     // create group

  1120     MCAExtendedStoredGroup* exGrp = iStoredGroups->CreateGroupL();

  1121     // Check memory level, leaves group creation with KErrDiskFull

  1122     // now if new group cannot be added to persistent database

  1123     TRAPD( err, iStoredGroups->CheckFreespaceLevelL( exGrp ) );

  1124     if ( err == KErrDiskFull )

  1125         {

  1126         // Make sure nothing is left to storage

  1127         iStoredGroups->DeleteGroupL( exGrp );

  1128         User::Leave( err );

  1129         }

  1130     exGrp->SetAdmin( ETrue );

  1131     exGrp->SetGroupNameL( aProperties->GroupName() );

  1132 

  1133     CHAT_DP( D_CHAT_LIT( "Group whisper, common=%d, priv=%d" ),

  1134              aProperties->IsPrivateAllowed(),

  1135              aPrivProperties->IsPrivateAllowed() );