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:  Group handling utilities

    15 *

    16 */

    17 

    18 

    19 //INCLUDES

    20 #include    "ImpsCSPAllErrors.h"

    21 #include    "CCAGroupUtils.h"

    22 

    23 #include    "chatngclient.hrh"

    24 #include    "ChatDefinitions.h"

    25 #include    "CAExternalInterface.h"

    26 #include    "CCAAppUi.h"

    27 

    28 #include    "ChatDebugPrint.h"

    29 #include    "CCAGroupPropertiesDialog.h"

    30 #include    "IMNoteMapper.h"

    31 #include    "IMDialogUtils.h"

    32 #include    "StringLoader.h"

    33 #include    "CCAStatusPaneHandler.h"

    34 #include    "CCAChatInfoArray.h"

    35 #include    "CAArrayUtils.h"

    36 #include    "CCAUISessionManager.h"

    37 #include    "IMUtils.h"

    38 #include    "CAUtils.h"

    39 #include    "CCAApp.h"

    40 #include    "CCAVariantFactory.h"

    41 #include    "CCAContactSelectionDialog.h"

    42 #include    "CCAUINGUtils.h"

    43 #include    "CCAPCUtils.h"

    44 

    45 #include    "MCAConversationMessage.h"

    46 #include	"MCAProcessManager.h"

    47 #include    "MCAGroupPC.h"

    48 #include 	"MCAGroupUtilsPC.h"

    49 

    50 

    51 #include    <chatNG.rsg>

    52 #include    <chatNG.mbg>

    53 #include    <impsgroupprops.h>

    54 #include    <aknnotewrappers.h>

    55 #include    <aknlists.h>

    56 #include    <bautils.h>

    57 

    58 // The Settings have been moved to Cenrep (also retained in the Resource file),

    59 // so the enums for keys and central repository header is added here

    60 #include 	"VariantKeys.h"

    61 

    62 // -----------------------------------------------------------------------------

    63 // CCAGroupUtils::CCAGroupUtils

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

    65 // might leave.

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

    67 //

    68 CCAGroupUtils::CCAGroupUtils( MCAViewSwitcher& aViewSwitcher )

    69         : iViewSwitcher( aViewSwitcher ),

    70         iCurrState( ESGCNone ),

    71         iPrevState( ESGCNone ),

    72         iScreenNamePtr( NULL, 0 )

    73     {

    74     }

    75 

    76 // -----------------------------------------------------------------------------

    77 // CCAGroupUtils::NewL

    78 // Two-phased constructor.

    79 // -----------------------------------------------------------------------------

    80 //

    81 CCAGroupUtils* CCAGroupUtils::NewLC( MCAViewSwitcher& aViewSwitcher )

    82     {

    83     CCAGroupUtils* temp = new( ELeave )CCAGroupUtils( aViewSwitcher );

    84     CleanupStack::PushL( temp );

    85     temp->ConstructL();

    86     return temp;

    87     }

    88 

    89 // -----------------------------------------------------------------------------

    90 // CCAGroupUtils::ResolveInviteConflictL

    91 // -----------------------------------------------------------------------------

    92 //

    93 void CCAGroupUtils::ResolveInviteConflictL( const TDesC& aGroup,

    94                                             CDesCArray& aArray )

    95     {

    96 

    97 

    98 

    99 

   100 

   101     // get the banned and all user list  from pc

   102     TInt countInvite( aArray.MdcaCount() );

   103 

   104     if ( !countInvite )

   105         {

   106         //no possible conflicts

   107         return;

   108         }

   109 

   110     iAppUi->ShowWaitDialogLC( R_QTN_GEN_CHAT_NOTE_PROCESSING, ETrue );

   111 

   112     TInt err( KErrNone );

   113 

   114 

   115     CDesCArray* banned = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   116     CleanupStack::PushL( banned );

   117 

   118     // Check server capabilities for group reject list

   119     if ( iAppUi->UISessionManager().IsSupported( CCAUISessionManager::EGroupRejectList ) )

   120         {

   121         // If supported, fetch list

   122         err = iGroupUtilsPC->GetRejectListL( *banned, aGroup );

   123         }

   124 

   125 

   126     if ( err == ECSPInsufficientGroupPrivileges )

   127         {

   128         //not enough group rights

   129         CleanupStack::PopAndDestroy( 2 ); // banned, wait

   130         return;

   131         }

   132 

   133     User::LeaveIfError( err );

   134 

   135     if ( banned->MdcaCount() == 0 )

   136         {

   137         //no possible conflict , nothing to do, just cleanup

   138         CleanupStack::PopAndDestroy( 2 ); // banned, wait

   139         return;

   140         }

   141 

   142 

   143     CDesCArray* userList = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   144     CleanupStack::PushL( userList );

   145     CDesCArray* screenNames  = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   146     CleanupStack::PushL( screenNames );

   147     CDesCArray* moders = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   148     CleanupStack::PushL( moders );

   149     CDesCArray* admins = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   150     CleanupStack::PushL( admins );

   151 

   152     err = iGroupUtilsPC->GetMembersL( *userList,

   153                                       *screenNames,

   154                                       *moders,

   155                                       *admins, aGroup );

   156     User::LeaveIfError( err );

   157 

   158     CDesCArray* newBanned = CAArrayUtils::CloneArrayLC( *banned );

   159     CDesCArray* newUserlist = CAArrayUtils::CloneArrayLC( *userList );

   160 

   161     TInt bannedCount( banned->MdcaCount() );

   162     TInt pos( KErrNotFound );

   163     TInt userlistInUse = userList->MdcaCount();

   164 

   165     for ( TInt i( 0 ); i < bannedCount; i++ )

   166         {

   167         pos = CAUtils::NeutralFind( aArray, banned->MdcaPoint( i ) );

   168         if ( pos != KErrNotFound )

   169             {

   170             //we have a conflict to resolve

   171             HBufC* prompt = StringLoader::LoadLC( R_QTN_CHAT_INVITE_REMOVE_BANNED,

   172                                                   iGroupUtilsPC->GetIdentificationL( banned->MdcaPoint( i ) ) );

   173 

   174             TInt ret( IMDialogUtils::DisplayQueryDialogL( R_GENERIC_YES_NO_CONFIRMATION_QUERY,

   175                                                           *prompt ) );

   176             CleanupStack::PopAndDestroy( prompt );

   177 

   178             if ( ( ret == EAknSoftkeyOk ) || ( ret == EAknSoftkeyYes )  )

   179                 {

   180                 //lets remove from the banned list

   181                 newBanned->Delete( i );

   182                 if ( userlistInUse )

   183                     {

   184                     newUserlist->AppendL( banned->MdcaPoint( i ) );

   185                     }

   186                 }

   187             else

   188                 {

   189                 //lets removed from the invitation list

   190                 aArray.Delete( pos );

   191                 }

   192             }

   193         }

   194 

   195     if ( newBanned->MdcaCount() != bannedCount )

   196         {

   197         //we need to update group props

   198         CDesCArray* newAdminlist = CAArrayUtils::CloneArrayLC( *admins );

   199         iGroupUtilsPC->UpdateGroupMembersL(

   200             aGroup,

   201             *admins, *newAdminlist,

   202             *userList, *newUserlist,

   203             *banned, *newBanned );

   204         CleanupStack::PopAndDestroy( newAdminlist );

   205         }

   206 

   207     // newUserlist , newBanned, admins, moders, screenNames

   208     CleanupStack::PopAndDestroy( 8 ); // banned, userlist, wait

   209     }

   210 

   211 // -----------------------------------------------------------------------------

   212 // CCAGroupUtils::~CCAGroupUtils

   213 // Destructor

   214 // -----------------------------------------------------------------------------

   215 //

   216 CCAGroupUtils::~CCAGroupUtils()

   217     {

   218     delete iGroupId;

   219     delete iAsyncCb;

   220     delete iJoinGroupId;

   221 

   222     if ( iWait.IsStarted() )

   223         {

   224         iWait.AsyncStop();

   225         }

   226 

   227     delete iAsyncGroupId;

   228     delete iAsyncScreenName;

   229     }

   230 

   231 // -----------------------------------------------------------------------------

   232 // CCAGroupUtils::ConstructL

   233 // Symbian 2nd phase constructor can leave.

   234 // -----------------------------------------------------------------------------

   235 //

   236 void CCAGroupUtils::ConstructL()

   237     {

   238     iAppUi = static_cast<CCAAppUi*>( CEikonEnv::Static()->AppUi() );

   239     iGroupPC = iAppUi->GetProcessManager().GetGroupInterface();

   240     iGroupUtilsPC = iAppUi->GetProcessManager().GetGroupUtilsInterface() ;

   241     }

   242 

   243 // -----------------------------------------------------------------------------

   244 // CCAGroupUtils::EditChatGroupPropertiesL

   245 // (other items were commented in a header).

   246 // -----------------------------------------------------------------------------

   247 //

   248 TInt CCAGroupUtils::EditChatGroupPropertiesL( const TDesC& aGroupId )

   249     {

   250 

   251 

   252     CHAT_DP_FUNC_ENTER( "EditChatGroupPropertiesL" );

   253 

   254     TBool areItemsEdited( EFalse );

   255 

   256     // create lists

   257     CDesCArray* userList = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   258     CleanupStack::PushL( userList );

   259     CDesCArray* screenNames  = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   260     CleanupStack::PushL( screenNames );

   261     CDesCArray* moders = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   262     CleanupStack::PushL( moders );

   263     CDesCArray* admins = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   264     CleanupStack::PushL( admins );

   265     CDesCArray* rejected = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   266     CleanupStack::PushL( rejected );

   267 

   268     TInt err( KErrNone );

   269     iAppUi->ShowWaitDialogL( R_QTN_GEN_CHAT_NOTE_PROCESSING, ETrue );

   270 

   271 

   272     TRAPD( leave, err = iGroupUtilsPC->GetGroupDataL( aGroupId, *userList, *screenNames,

   273                                                       *moders, *admins, *rejected ) );

   274 

   275     iAppUi->DismissWaitDialogL( leave );

   276 

   277     if ( err != KErrNone )

   278         {

   279         IMNoteMapper::ShowNoteL( err );

   280         CleanupStack::PopAndDestroy( 5, userList ); // rejected, admins,

   281         // moders, screenNames, userList

   282         return EAknSoftkeyCancel;

   283         }

   284 

   285     iGroupUtilsPC->MoveOwnIdToFirstL( *admins );

   286 

   287     // store the original arrays

   288     // (we'll ignore screennames and moderators)

   289     CDesCArray* oldUserList = CAArrayUtils::CloneArrayLC( *userList );

   290     CDesCArray* oldAdmins = CAArrayUtils::CloneArrayLC( *admins );

   291     CDesCArray* oldRejected = CAArrayUtils::CloneArrayLC( *rejected );

   292 

   293 

   294     // construct the groupproperties dialog

   295     CCAGroupPropertiesDialog* groupPropDialog =

   296         new( ELeave )CCAGroupPropertiesDialog(

   297         *iViewSwitcher.CAStatusPane(),

   298         ETrue,

   299         *userList,

   300         *admins,

   301         *rejected,

   302         aGroupId,

   303         areItemsEdited );

   304 

   305     CleanupStack::PushL( groupPropDialog );

   306     groupPropDialog->ConstructL( R_CHATCLIENT_MENUBAR_CHAT_PROPERTIES_VIEW );

   307 

   308     // launch the dialog

   309     CleanupStack::Pop( groupPropDialog );

   310     TInt result( groupPropDialog->ExecuteLD( R_CHATCLIENT_GROUPPROPERTIES_DLG ) );

   311     CHAT_DP( D_CHAT_LIT(

   312                  "CCAGroupUtils::EditChatGroupPropertiesL areItemsEdited: %d" ),

   313              areItemsEdited );

   314 

   315     if ( ( result == EAknSoftkeyDone || result == EAknSoftkeyYes ) && areItemsEdited )

   316         {

   317         // Display wait note. Move this to utils side.

   318         iAppUi->ShowWaitDialogL( R_QTN_GEN_NOTE_SAVING, ETrue );

   319 

   320         // Update properties

   321         TInt err( KErrNone );

   322 

   323         TRAP( leave, err = iGroupUtilsPC->ProcessEditedGroupPropertiesL(

   324                                aGroupId, *oldAdmins, *admins, *oldUserList, *userList,

   325                                *oldRejected, *rejected ) );

   326 

   327         iAppUi->DismissWaitDialogL( leave );

   328         if ( err != KErrNone )

   329             {

   330             IMNoteMapper::ShowNoteL( err );

   331             CleanupStack::PopAndDestroy( 8, userList );

   332             return EAknSoftkeyCancel;

   333             }

   334         }

   335     else if ( result == EAknSoftkeyExit )

   336         {

   337         CEikonEnv::Static()->EikAppUi()->HandleCommandL( EChatClientCmdExit );

   338         }

   339 

   340     CleanupStack::PopAndDestroy( 8, userList );

   341     CHAT_DP_FUNC_DONE( "EditChatGroupPropertiesL" );

   342     return result;

   343     }

   344 

   345 // utilsside_complete

   346 // -----------------------------------------------------------------------------

   347 // CCAGroupUtils::AskScreenNameL

   348 // (other items were commented in a header).

   349 // -----------------------------------------------------------------------------

   350 //

   351 TInt CCAGroupUtils::AskScreenNameL( TDes& aScreenName )

   352     {

   353     // don't call this directly, call ScreenNameQueryL instead

   354 

   355     // make sure we're not capturing

   356     TBool wasCapturing = iAppUi->AreEventsCaptured();

   357     iAppUi->ReleaseCapturingL();

   358 

   359     // ask for the screenname

   360     TInt result = IMDialogUtils::DisplayTextQueryDialogL( aScreenName,

   361                                                           R_CHATCLIENT_CLIST_SN_PROMPT,

   362                                                           R_CHATCLIENT_CLIST_SN_QUERY,

   363                                                           ETrue // T9

   364                                                         );

   365 

   366     if ( wasCapturing )

   367         {

   368         // restore capturing

   369         iAppUi->CaptureEventsL();

   370         }

   371 

   372     return result;

   373     }

   374 // pcside_partially ..impact has to be analysed

   375 

   376 

   377 // -----------------------------------------------------------------------------

   378 // CCAGroupUtils::CreateNewChatL

   379 // (other items were commented in a header).

   380 // -----------------------------------------------------------------------------

   381 //

   382 HBufC* CCAGroupUtils::CreateNewChatL( TInt aResourceId, const TUid aViewId,

   383                                       TBool aContactFound, TEnumsPC::TListSelectionType aSelType,

   384                                       TInt aSelectedListIndex   )

   385     {

   386     CHAT_DP_FUNC_ENTER( "CreateNewChatL" );

   387 

   388     if ( !iAppUi->UISessionManager().IsLoggedIn() )

   389         {

   390         iAppUi->UISessionManager().LoginL( MCAUiLoginCmdCB::ELogin );

   391         if ( !iAppUi->UISessionManager().IsLoggedIn() )

   392             {

   393             // Still not logged in

   394             // Can't continue

   395             return NULL;

   396             }

   397         }

   398 

   399     if ( IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_SIMPLE_GROUP_CREATION ) )

   400         {

   401         // simplified new school group creation

   402         CHAT_DP_FUNC_DONE( "CreateNewChatL" );

   403         return CreateNewChatSimpleL( aResourceId, aViewId , aContactFound, aSelType, /*aOnlineContacts*/ aSelectedListIndex );

   404         }

   405     else

   406         {

   407         // normal old school group creation

   408         CHAT_DP_FUNC_DONE( "CreateNewChatL" );

   409         return CreateNewChatNormalL( aResourceId, aViewId );

   410         }

   411     }

   412 //pcside_partially

   413 

   414 // -----------------------------------------------------------------------------

   415 // CCAGroupUtils::CreateNewChatNormalL

   416 // (other items were commented in a header).

   417 // -----------------------------------------------------------------------------

   418 //

   419 HBufC* CCAGroupUtils::CreateNewChatNormalL(

   420     TInt aResourceId,

   421     const TUid aViewId )

   422     {

   423     CHAT_DP_FUNC_ENTER( "CreateNewChatNormalL" );

   424 

   425     TBool areItemsEdited( EFalse );

   426 

   427     // create lists

   428     CDesCArray* userList = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   429     CleanupStack::PushL( userList );

   430     CDesCArray* admins = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   431     CleanupStack::PushL( admins );

   432     CDesCArray* rejected = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   433     CleanupStack::PushL( rejected );

   434 

   435     // add own wvid to admins list

   436     // Use new function for this

   437 

   438 

   439     iGroupUtilsPC->MoveOwnIdToFirstL( *admins );

   440 

   441     // note: groupprops must be at the top of the cleanupstack

   442     // so that we can get them out before call to creategroupl

   443     CImpsCommonGroupProps* groupProps = CImpsCommonGroupProps::NewL();

   444     CleanupStack::PushL( groupProps );

   445     CImpsPrivateGroupProps* privateProps = CImpsPrivateGroupProps::NewL();

   446     CleanupStack::PushL( privateProps );

   447 

   448     CImpsCommonGroupProps* newGroupProps = CImpsCommonGroupProps::NewL();

   449     CleanupStack::PushL( newGroupProps );

   450     CImpsPrivateGroupProps* newPrivateProps = CImpsPrivateGroupProps::NewL();

   451     CleanupStack::PushL( newPrivateProps );

   452 

   453     // construct and launch the groupproperties dialog

   454     CCAGroupPropertiesDialog* groupPropDialog =

   455         new( ELeave )CCAGroupPropertiesDialog(

   456         *iViewSwitcher.CAStatusPane(),

   457         /**groupProps, *privateProps, *newGroupProps, *newPrivateProps,*/

   458 

   459         EFalse,

   460         *userList, *admins, *rejected,

   461         KNullDesC,

   462         areItemsEdited );

   463 

   464     CleanupStack::PushL( groupPropDialog );

   465     groupPropDialog->ConstructL( R_CHATCLIENT_MENUBAR_CHAT_PROPERTIES_VIEW );

   466     CleanupStack::Pop( groupPropDialog );

   467     TInt result( groupPropDialog->ExecuteLD(

   468                      R_CHATCLIENT_GROUPPROPERTIES_DLG ) );

   469     CHAT_DP( D_CHAT_LIT(

   470                  "CCAGroupUtils::CreateNewChatNormalL areItemsEdited: %d" ),

   471              areItemsEdited );

   472 

   473     HBufC* groupId = NULL;

   474 

   475     if ( result == EAknSoftkeyDone || result == EAknSoftkeyYes )

   476         {

   477         CCAUINGUtils::SetTitleL( aResourceId, aViewId );

   478 

   479         // ask screenname query before creation, or re-use alias

   480         TBool joinGroup( EFalse );

   481 

   482         // fetch the default or recently used screen name pointer

   483         iScreenNamePtr.Set( iAppUi->ScreenNamePtr()->Des() );

   484         TInt ret = ScreenNameQueryL( iScreenNamePtr );

   485 

   486         if ( ret == EAknSoftkeyDone || ret == EAknSoftkeyOk )

   487             {

   488             CDesCArray* noteTexts = new( ELeave ) CDesCArrayFlat(

   489                 KArrayGranularity );

   490             CleanupStack::PushL( noteTexts );

   491             noteTexts->AppendL( newGroupProps->GroupName() );

   492             noteTexts->AppendL( iScreenNamePtr );

   493             HBufC* waitMsg = StringLoader::LoadLC(

   494                                  RSC_CHAT_JOIN_WAIT, *noteTexts );

   495             iAppUi->ShowWaitDialogL( *waitMsg, ETrue );

   496             CleanupStack::PopAndDestroy( 2, noteTexts ); // waitMsg, noteTexts

   497             joinGroup = ETrue;

   498             }

   499         else

   500             {

   501             iAppUi->ShowWaitDialogL( R_QTN_GEN_CHAT_NOTE_PROCESSING, ETrue );

   502             }

   503 

   504         // check the autodeletion variation flag

   505         if ( IMUtils::IntResourceValueL( RSC_CHAT_VARIATION_GROUP_AUTODELETE ) )

   506             {

   507             newGroupProps->SetAutoDelete( EImpsPropYes );

   508             }

   509 

   510         // CreateGroupL takes the ownership of the properties

   511         CleanupStack::Pop( 2, newGroupProps ); // newPrivateProps, newGroupProps

   512         CleanupStack::PopAndDestroy( 2, groupProps ); // privateProps, groupProps

   513 

   514         TInt error( 0 );

   515         TBool whisperingAllowed =

   516             IMUtils::IntResourceValueL(

   517                 RSC_CHAT_VARIATION_GROUP_WHISPER ) == 1;

   518         TRAPD( err, groupId = iGroupUtilsPC->CreateGroupSimpleL( iScreenNamePtr,

   519                                                                  joinGroup,

   520                                                                  whisperingAllowed,

   521                                                                  error ) );

   522 

   523         // if CreateGroupL returns NULL, it couldn't create the group

   524         if ( groupId )

   525             {

   526             // Delete old one. No need to store it.

   527             // Cannot put groupId to CleanupStack because if PushL leaves then

   528             // wait note would be shown forever

   529             delete iGroupId;

   530             iGroupId = groupId;

   531             }

   532 

   533         CHAT_DP( D_CHAT_LIT(

   534                      "CCAGroupUtils::CreateNewChatNormalL()  iGroupInterface->CreateGroupL() error = %d, err = %d" ),

   535                  error, err );

   536 

   537         if ( err == KErrNone && error == KErrNone && groupId )

   538             {

   539             TRAPD( leave, iGroupUtilsPC->AddGroupMembersL( *groupId, *admins, *userList, *rejected ) );

   540             iAppUi->DismissWaitDialogL( leave );

   541 

   542             if ( joinGroup )

   543                 {

   544                 // switch to joined group (ETrue = ask invite query)

   545                 SwitchToJoinedGroupL( EFalse, *groupId, NULL, ETrue );

   546                 }

   547             }

   548         // Engine couldn't find a unique group id

   549         else if ( err == KErrNone && error == KErrNone && ! groupId )

   550             {

   551             // Imps_ERROR_BASE - 10000 is an unknown error

   552             // ("server error") to note mapper

   553             iAppUi->DismissWaitDialogL( Imps_ERROR_BASE - 10000 );

   554             }

   555         else

   556             {

   557             iAppUi->DismissWaitDialogL( err );

   558             if ( error == ECSPAccepted )

   559                 {

   560                 CCAUINGUtils::HandlePartialSuccessL();

   561                 }

   562             else

   563                 {

   564                 IMNoteMapper::ShowNoteL( error );

   565                 if ( error == ECSPMaxNumberOfGroupsForUser ||

   566                      error == ECSPMaxNumberOfGroupsForServer )

   567                     {

   568                     DisplayCreatedChatRoomsListL();

   569                     }

   570                 }

   571             }

   572         }

   573     else

   574         {

   575         // user cancelled the creation

   576         CleanupStack::PopAndDestroy( 4, groupProps ); //newPrivateProps,

   577         // newGroupProps, privateProps, groupProps

   578         CCAUINGUtils::SetTitleL( aResourceId, aViewId );

   579         if ( result == EAknSoftkeyExit )

   580             {

   581             CEikonEnv::Static()->EikAppUi()->HandleCommandL(

   582                 EChatClientCmdExit );

   583             }

   584         }

   585     CleanupStack::PopAndDestroy( 3, userList ); // rejected, admins, userList

   586 

   587     if ( groupId )

   588         {

   589         // groupId points to iGroupId and the ownership is

   590         // passed to calling function so we can't delete the iGroupId

   591         iGroupId = NULL;

   592         }

   593     // no leaving code allowed between (iGroupId = NULL;) and (return groupId;)

   594     CHAT_DP_FUNC_DONE( "CreateNewChatNormalL" );

   595 

   596     return groupId;

   597     }

   598 

   599 // -----------------------------------------------------------------------------

   600 // CCAGroupUtils::CreateNewChatSimpleL

   601 // (other items were commented in a header).

   602 // -----------------------------------------------------------------------------

   603 //

   604 HBufC* CCAGroupUtils::CreateNewChatSimpleL( TInt /* aResourceId */,

   605                                             const TUid /* aViewId */, TBool aContactFound,

   606                                             TEnumsPC::TListSelectionType aSelType,

   607                                             TInt aSelectedListIndex )

   608     {

   609     CHAT_DP_FUNC_ENTER( "CreateNewChatSimpleL" );

   610 

   611     CDesCArray* inviteList = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   612     CleanupStack::PushL( inviteList );

   613 

   614     HBufC* groupId = NULL;

   615     HBufC* groupName = HBufC::NewLC( KMaxChatGroupLenght );

   616     HBufC* inviteMsg = HBufC::NewLC( KInviteMessageMaxLength );

   617     TPtr chatGroupName( groupName->Des() );

   618     TPtr chatInvite( inviteMsg->Des() );

   619     TPtr screenName( iAppUi->ScreenNamePtr()->Des() );

   620     TBool inviteSupported( iAppUi->UISessionManager().IsSupported( CCAUISessionManager::EInvite ) );

   621 

   622 

   623 

   624     TInt result = EAknSoftkeyOk;

   625     TInt inviteError = KErrNone;

   626 

   627     // number of online friends

   628     //TInt onlineCount = 0;

   629 

   630     iCurrState = ESGCInviteContacts;

   631     iPrevState = ESGCNone;

   632 

   633     TBool exitFSM = EFalse;

   634 

   635     //   MAKE SURE EACH STATE HAS CLEANUPSTACK BALANCED UPON EXIT

   636     //   This means: DO NOT CleanupStack::Push in one state, and

   637     //   Pop/PopAndDestroy in the other. This also means to do Pop/PopAndDestroy

   638     //   before a state transition inside a state.

   639 

   640     // handle simplified group creation within a finite state machine

   641     // construction

   642 

   643 

   644 

   645     while ( ! exitFSM )

   646         {

   647         switch ( iCurrState )

   648             {

   649                 // BEGIN state: choosing the contacts to be invited

   650             case ESGCInviteContacts :

   651                 {

   652                 // we only ask for invite if invite function is supported

   653                 result = EAknSoftkeyOk;

   654 

   655 

   656                 if ( aContactFound  )

   657                     {

   658 

   659 

   660                     // We have online friends, so show the multiselection view

   661                     CCAAppUi* appUi = static_cast<CCAAppUi*>(

   662                                           CCoeEnv::Static()->AppUi() );

   663 

   664 

   665                     MCASkinVariant* skinVar = static_cast<CCAApp*>(

   666                                                   appUi->Application() )->VariantFactory()->SkinVariantL();

   667                     CDesCArrayFlat* selectedContacts =

   668                         new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   669                     CleanupStack::PushL( selectedContacts );

   670 

   671                     // Show selection dialog

   672 

   673                     TBool isSelected( EFalse );

   674                     // show selection dialog

   675 

   676                     isSelected = CCAContactSelectionDialog::ShowDialogL(

   677                                      *selectedContacts,

   678                                      *appUi->GetProcessManager().GetArrayInterface(),

   679                                      *skinVar,

   680                                      *appUi->GetProcessManager().GetSettingsInterface(),

   681                                      appUi->MbmFullPath(),

   682                                      aSelType,

   683                                      R_CONTACT_SELECTION_DIALOG,

   684                                      *iViewSwitcher.CAStatusPane(),

   685                                      NULL,

   686                                      TEnumsPC::EFilterNotDefined,

   687                                      TEnumsPC::EFilterNotDefined,

   688                                      EFalse,

   689                                      aSelectedListIndex

   690                                      , &exitFSM );

   691                     if ( exitFSM )

   692                         {

   693                         CleanupStack::PopAndDestroy();

   694                         break;

   695                         }

   696 

   697                     if ( isSelected )

   698                         {

   699                         // code merge 14 Nov, 2006

   700                         // Get rid of contacts with duplicate ids

   701                         CCAPCUtils::RemoveDuplicateWVIds( *selectedContacts );

   702                         // Populate "real" invite list

   703                         TInt inviteCount( selectedContacts->MdcaCount() );

   704 

   705                         for ( TInt i = 0; i < inviteCount; ++i )

   706                             {

   707 

   708                             TPtrC wvid( selectedContacts->MdcaPoint( i ) );

   709 

   710                             inviteList->AppendL( wvid );

   711                             }

   712 

   713                         // Continue creation if user selected invitees

   714                         if ( inviteList->Count() > 0 )

   715                             {

   716                             result = EAknSoftkeyOk;

   717                             }

   718                         else

   719                             {

   720                             result = EAknSoftkeyCancel;

   721                             }

   722 

   723 

   724                         }

   725                     else

   726                         {

   727                         result = EAknSoftkeyCancel;

   728                         }

   729 

   730                     CleanupStack::PopAndDestroy(); // selectedContacts.Close()

   731                     }

   732 

   733 

   734                 StateChange( result, KErrNone, ESGCGroupName );

   735                 break;

   736                 }

   737 

   738             // ask the group name

   739             case ESGCGroupName :

   740                 {

   741                 if ( aSelType == TEnumsPC::ESingleListMultiSelect )

   742                     {

   743                     MCAMainViewArrayPC* mainViewArrayPC =

   744                         iAppUi->GetProcessManager().GetArrayInterface();

   745                     chatGroupName = mainViewArrayPC->DisplayName( aSelectedListIndex );

   746                     }

   747                 iGroupUtilsPC->GetDefaultGroupNameL( chatGroupName, aSelType );

   748                 // since the user didn't cancel, ask the group name

   749                 result = IMDialogUtils::DisplayTextQueryDialogL( chatGroupName,

   750                                                                  R_CHATCLIENT_CHATLIST_CREATE_GROUP_NAME,

   751                                                                  R_CHATCLIENT_CHATLIST_CREATE_GROUP_NAME_QUERY,

   752                                                                  ETrue // T9

   753                                                                );

   754 

   755                 StateChange( result, KErrNone, ESGCInviteMessage );

   756                 break;

   757                 }

   758 

   759             // ask the invitation message

   760             case ESGCInviteMessage :

   761                 {

   762                 if ( inviteList->Count() > 0 )

   763                     {

   764                     // the user didn't cancel, so ask the invitation message

   765                     result = IMDialogUtils::DisplayTextQueryDialogL(

   766                                  chatInvite,

   767                                  R_CHAT_INVITE_MSG_DQ,

   768                                  R_CHAT_INVITE_MESSAGE_QUERY,

   769                                  ETrue // T9

   770                              );

   771 

   772                     StateChange( result, KErrNone, ESGCScreenName );

   773                     }

   774                 else

   775                     {

   776                     // nobody in invite list, force state change

   777                     StateChange( EAknSoftkeyOk, KErrNone, ESGCScreenName );

   778                     }

   779                 break;

   780                 }

   781 

   782             // ask the screen name (or use alias)

   783             case ESGCScreenName :

   784                 {

   785                 result = ScreenNameQueryL( screenName );

   786                 StateChange( result, KErrNone, ESGCCreateGroup );

   787                 break;

   788                 }

   789 

   790             // do the actual creation, sending of invitations,

   791             // and joining to the group

   792             case ESGCCreateGroup :

   793                 {

   794                 // finalize chat group creation and join it, then send all the

   795                 // invitations

   796                 // put up the wait note

   797                 // wait note is dismissed by the last state

   798                 HBufC* waitMsg = StringLoader::LoadLC(

   799                                      R_CHAT_CREATING_CHAT_GROUP );

   800                 iAppUi->ShowWaitDialogL( *waitMsg, ETrue );

   801                 CleanupStack::PopAndDestroy(); // waitMsg

   802 

   803                 TInt err;

   804                 TInt error = 0;

   805                 TRAP( err, groupId = iGroupUtilsPC->CreateGroupL( screenName, chatGroupName, error ) );

   806 

   807 

   808                 // CreateGroupL leaves with KErrDiskFull under low flash

   809                 // memory conditions (below critical level, 128 kB)

   810                 // stop group creation here in that case

   811                 if ( err == KErrDiskFull )

   812                     {

   813                     // Use StateChange to advance to error state

   814                     StateChange( EAknSoftkeyOk, err, ESGCNone );

   815                     break;

   816                     }

   817 

   818                 // if CreateGroupL returns NULL, it couldn't create the group

   819                 if ( groupId )

   820                     {

   821                     // Delete old one. No need to store it.

   822                     // Cannot put groupId to CleanupStack because if PushL leaves then

   823                     // wait note would be shown forever

   824                     delete iGroupId;

   825                     iGroupId = groupId;

   826                     }

   827 

   828                 // note, the ESGCDoJoin state and ESGCError states dismiss the

   829                 // wait note.  ESGCDoSendInvite makes a new wait note, and it

   830                 // gets dismissed upon successful state change to ESGCDoJoin

   831 

   832                 // error contains the actual nw error now

   833                 StateChange( EAknSoftkeyOk, error, ESGCDoSendInvite );

   834                 break;

   835                 }

   836 

   837             // send the invitation(s),

   838             case ESGCDoSendInvite :

   839                 {

   840                 TInt retval = KErrNone;

   841 

   842                 if ( inviteList->MdcaCount() > 0 )

   843                     {

   844                     // we have invitations, so send them

   845 

   846                     // Show wait-note. Error state dismisses it.

   847                     iAppUi->ShowWaitDialogL( inviteList->MdcaCount() > 1 ?

   848                                              R_QTN_CHAT_INVITE_SENDING_MANY : R_QTN_CHAT_INVITE_SENDING,

   849                                              ETrue );

   850 

   851                     // Send invitation

   852                     TRAP( retval, iGroupUtilsPC->SendInvitationsL( *inviteList, *groupId, *inviteMsg ); );

   853                     }

   854 

   855                 // Ignore these errors at least for now and continue group creation.

   856                 // UI CR coming for 3.1

   857                 if ( retval == ECSPPartiallySuccessful || retval == ECSPCannotDeliver

   858                      || retval == ECSPRecipientBlockedSender )

   859                     {

   860                     inviteError = retval;

   861                     retval = KErrNone;

   862                     }

   863 

   864                 StateChange( EAknSoftkeyOk, retval, ESGCDoJoin );

   865                 break;

   866                 }

   867 

   868             // and joining to the group

   869             case ESGCDoJoin:

   870                 {

   871                 // join to group (groupId contains ID), then

   872                 // switch to joined group

   873                 TInt leave;

   874                 TInt err = KErrNone;

   875                 TRAP( leave, err = iGroupUtilsPC->JoinGroupL( *groupId, screenName, ETrue, ETrue ) );

   876 

   877                 // Get rid of wait-note. It's either

   878                 // "Creating chat group" or "Sending invitation"

   879                 // at this point

   880                 iAppUi->DismissWaitDialogL( err );

   881 

   882                 // If there was an error in sending invitation show error note

   883                 // at this point right before view switching

   884                 if ( inviteError != KErrNone &&  inviteError != ECSPRecipientBlockedSender )

   885                     {

   886                     IMNoteMapper::ShowNoteL( inviteError );

   887                     }

   888                 if ( inviteError == ECSPRecipientBlockedSender )

   889                     {

   890                     TInt inviteeCount = inviteList->MdcaCount();

   891                     for ( TInt cnt = 0; cnt < inviteeCount; cnt++ )

   892                         {

   893                         IMNoteMapper::ShowNoteL( inviteError,

   894                                                  CCAPCUtils::DisplayId( inviteList->MdcaPoint( cnt )  ) );

   895                         }

   896                     }

   897                 // screen name cannot be in use since we just created the group...

   898                 switch ( err )

   899                     {

   900                     case ECSPSuccessful:    // flowthrough

   901                     case KErrNone:

   902                         {

   903                         // ok, switch to joined group

   904                         SwitchToJoinedGroupL( EFalse, *groupId );

   905                         break;

   906                         }

   907 

   908                     default:

   909                         {

   910                         // will force state change to error state

   911                         StateChange( EAknSoftkeyOk, err, ESGCDoJoin );

   912                         break;

   913                         }

   914                     }

   915 

   916                 // final state, all done.

   917                 exitFSM = ETrue;

   918                 break;

   919                 }

   920 

   921             // got some network or other error during the process

   922             // not all states will end up here. only ESGCCreateGroup and

   923             // ESGCInviteAndJoin.

   924             case ESGCError :

   925                 {

   926                 // safe to call even without a wait dialog active

   927                 iAppUi->DismissWaitDialogL( iNwError );

   928 

   929                 // must be the last

   930                 exitFSM = ETrue;

   931 

   932                 if ( iNwError == ECSPMaxNumberOfGroupsForUser ||

   933                      iNwError == ECSPMaxNumberOfGroupsForServer )

   934                     {

   935                     if ( DisplayCreatedChatRoomsListL() == EAknSoftkeyOk )

   936                         {

   937                         exitFSM = EFalse; // Continue creation.

   938                         StateChange( EAknSoftkeyOk, KErrNone, ESGCCreateGroup );

   939                         }

   940                     }

   941                 break;

   942                 }

   943 

   944             // cancel group creation query

   945             case ESGCQueryCancel :

   946                 {

   947                 result = IMDialogUtils::DisplayQueryDialogL(

   948                              R_CHAT_GENERIC_CANCEL_CONFIRMATION_QUERY,

   949                              R_QTN_CHAT_CANCEL_GROUP_CREATION );

   950 

   951                 if ( ( result == EAknSoftkeyOk ) ||

   952                         ( result == EAknSoftkeyYes ) )

   953                     {

   954                     // user really wants to cancel, so

   955                     // let's get out of here

   956                     exitFSM = ETrue;

   957                     }

   958                 else if( !result )

   959                 	{

   960                 	if( !iAppUi->GetIsFSWExitFlag() )

   961                 		{

   962                 	    StateChange( EAknSoftkeyOk, KErrNone, iPrevState );

   963                 		}

   964                 	else

   965                 		{

   966                 		exitFSM = ETrue;

   967                 		}

   968                 	}

   969                 else

   970                     {

   971                     // user cancelled the cancel query, so go back to the state

   972                     // we were in

   973                     iCurrState = iPrevState;

   974                     }

   975                 break;

   976                 }

   977 

   978             default :

   979                 {

   980                 // WRONG state, leave

   981                 User::Leave( KErrArgument );

   982                 break;

   983                 }

   984             }

   985         }

   986 

   987     iCurrState = ESGCNone;

   988     iPrevState = ESGCNone;

   989 

   990     // if the user cancels in any step, we end up here

   991     // and do cleanup. also, if we're successful

   992     CleanupStack::PopAndDestroy( inviteMsg );

   993     CleanupStack::PopAndDestroy( groupName );

   994     CleanupStack::PopAndDestroy( inviteList );

   995 

   996     CHAT_DP_FUNC_DONE( "CreateNewChatSimpleL" );

   997     return NULL;

   998     }

   999 // pcside_completely

  1000 

  1001 // pcside_completely

  1002 // -----------------------------------------------------------------------------

  1003 // CCAGroupUtils::ScreenNameQueryL

  1004 // (other items were commented in a header).

  1005 // -----------------------------------------------------------------------------

  1006 //

  1007 TInt CCAGroupUtils::ScreenNameQueryL( TDes& aScreenName )

  1008     {

  1009     TInt askScreenName = IMUtils::IntResourceValueL(

  1010                              RSC_CHAT_VARIATION_SCREENNAME_QUERY );

  1011 

  1012     TInt result = 0;

  1013 

  1014 

  1015     iGroupUtilsPC->ScreenNameQueryL( aScreenName );

  1016 

  1017     if ( ! askScreenName )

  1018         {

  1019         // assume as accepted as the query dialog is not to be shown

  1020         result = EAknSoftkeyOk;

  1021         }

  1022     else

  1023         {

  1024         result = AskScreenNameL( aScreenName );

  1025         }

  1026 

  1027     return result;

  1028     }

  1029 

  1030 // -----------------------------------------------------------------------------

  1031 // CCAGroupUtils::PrepareToSwitchBackL

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

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

  1034 //

  1035 void CCAGroupUtils::PrepareToSwitchBackL( const TDesC& aGroupID,

  1036                                           TUid aPrevView,

  1037                                           TUid aNextView )

  1038     {

  1039     TUid messageID;

  1040 

  1041     HBufC8* myMessage = NULL;

  1042 

  1043     TCADnlChatViewBuf chatMsgBuf;

  1044     TCADnlConvViewBuf convMsgBuf;

  1045 

  1046 

  1047     TCADnlChatView dnlChatView;

  1048     if ( aPrevView == KUidChatView )

  1049         {

  1050         TBool foundGroup = iGroupUtilsPC->FindGroup( aGroupID );

  1051 

  1052         dnlChatView.iGroupId =

  1053             aGroupID.Left( dnlChatView.iGroupId.MaxLength() );

  1054         dnlChatView.iIsForwarded = EFalse;

  1055         dnlChatView.iInviteQuery = EFalse;

  1056         if ( foundGroup )

  1057             {

  1058             dnlChatView.iGroupName = iGroupUtilsPC->GetEngineDefaultGroupName( aGroupID );

  1059             }

  1060 

  1061         chatMsgBuf = dnlChatView;

  1062         messageID = KUidChatViewMsgId;

  1063         myMessage = chatMsgBuf.AllocLC();

  1064         }

  1065     else // aPrevView == KUidConversationsView

  1066         {

  1067         TCADnlConvView dnlConView;

  1068         dnlConView.iWVID = aGroupID;

  1069         dnlConView.iIsForwarded = EFalse;

  1070         dnlConView.iSAPChanged = EFalse;

  1071         dnlConView.iSwitchTab = EFalse;

  1072 

  1073         convMsgBuf = dnlConView;

  1074         messageID = KUidConvViewMsgId;

  1075         myMessage = convMsgBuf.AllocLC();

  1076         }

  1077 

  1078 

  1079     CleanupStack::Pop( myMessage );

  1080 

  1081     //myMessage ownership is taken by RegisterSwitchBack

  1082     iAppUi->RegisterSwitchBack( aPrevView, messageID, myMessage, aNextView );

  1083     }

  1084 

  1085 // -----------------------------------------------------------------------------

  1086 // CCAGroupUtils::StateChange

  1087 // (other items were commented in a header).

  1088 // -----------------------------------------------------------------------------

  1089 //

  1090 void CCAGroupUtils::StateChange( TInt aAknResult, TInt aErrorCode,

  1091                                  TSGCState aNewState )

  1092     {

  1093     iPrevState = iCurrState;

  1094 

  1095     if ( aErrorCode != KErrNone )

  1096         {

  1097         // got an error, go to error state and handle it

  1098         iCurrState = ESGCError;

  1099         iNwError = aErrorCode;

  1100         return;

  1101         }

  1102 

  1103     // new state for FSM, changes FSM state

  1104     if ( ( aAknResult != EAknSoftkeyOk ) && ( aAknResult != EAknSoftkeyYes )

  1105          && ( aAknResult != EAknSoftkeyDone ) )

  1106         {

  1107         // user cancelled the query in a step, verify

  1108         // with a query

  1109         iCurrState = ESGCQueryCancel;

  1110         }

  1111     else

  1112         {

  1113         // user didn't cancel, so move to a new state

  1114         iCurrState = aNewState;

  1115         }

  1116     }

  1117 

  1118 // Callback for asynchronous joining to the group

  1119 // after the login has been completed

  1120 TInt JoinGroupCallBack( TAny* aPtr )

  1121     {

  1122     return static_cast< CCAGroupUtils* >( aPtr )->DoAsyncJoin();

  1123     }

  1124 

  1125 // -----------------------------------------------------------------------------

  1126 // CCAGroupUtils::DoAsyncJoin

  1127 // (other items were commented in a header).

  1128 // -----------------------------------------------------------------------------

  1129 //

  1130 TInt CCAGroupUtils::DoAsyncJoin()

  1131     {

  1132     CHAT_DP_FUNC_ENTER( "JoinGroupCallBack" );

  1133 

  1134     TRAP( iAsyncLeave, iErr = JoinGroupL(

  1135                                   EFalse,