1 /*

     2 * Copyright (c) 2002-2007 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:  A SIM contact view subsession.

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include "RVPbkSimCntView.h"

    22 

    23 // VPbkSimServer

    24 #include <VPbkSimServerOpCodes.h>

    25 #include <VPbkSimStoreTemplateFunctions.h>

    26 

    27 // VPbkSimStoreImpl

    28 #include <RVPbkStreamedIntArray.h>

    29 #include <CVPbkSimFieldTypeFilter.h>

    30 #include <RVPbkSimStore.h>

    31 

    32 // VPbkEngUtils

    33 #include <VPbkIPCPackage.h>

    34 

    35 // System includes

    36 #include <s32mem.h>

    37 

    38 // CONSTANTS

    39 

    40 // Initial size for the buffer used to retrieve a view contact

    41 const TInt KInitialReadBufSize = 128;

    42 // Maximum size for the buffer used to retrieve a view contact

    43 const TInt KMaxReadBufSize = 4 * KInitialReadBufSize;

    44 // Double factor

    45 const TInt KTwice = 2;

    46 // Max attempts to get sort order.

    47 const TInt KMaxSortOrderAttempts = 5;

    48 

    49 // ============================= LOCAL FUNCTIONS ============================

    50 

    51 namespace {

    52 

    53 // --------------------------------------------------------------------------

    54 // ExternalizeSortOrderLC

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

    56 //

    57 HBufC8* ExternalizeSortOrderLC( const RVPbkSimFieldTypeArray& aSortOrder )

    58     {

    59     TInt size = aSortOrder.ExternalizedSize();

    60     HBufC8* buf = HBufC8::NewLC( size );

    61     TPtr8 ptr( buf->Des() );

    62     RDesWriteStream stream( ptr );

    63     CleanupClosePushL( stream );

    64     stream << aSortOrder;

    65     ptr.SetLength( size );

    66     CleanupStack::PopAndDestroy(); // stream

    67     return buf;

    68     }

    69 

    70 // --------------------------------------------------------------------------

    71 // CountBufferSize

    72 // --------------------------------------------------------------------------

    73 // 

    74 TInt CountBufferSize( const MDesCArray& aFindStrings )

    75     {

    76     TInt size( sizeof(TInt) );

    77     const TInt count( aFindStrings.MdcaCount() );

    78     for ( TInt i(0); i < count; ++i )

    79         {

    80         size += sizeof(TInt);

    81         size += aFindStrings.MdcaPoint( i ).Size();

    82         }

    83     return size;        

    84     }

    85     

    86 // --------------------------------------------------------------------------

    87 // ExternalizeFindStringsL

    88 // --------------------------------------------------------------------------

    89 //    

    90 void ExternalizeFindStringsL( 

    91         HBufC8*& aBuffer,

    92         const MDesCArray& aFindStrings )

    93     {

    94     // Count needed buffer size

    95     const TInt size( CountBufferSize( aFindStrings ) );

    96     

    97     // check if we have buffer

    98     if ( aBuffer )

    99         {

   100         // check if the buffer is big enough

   101         TPtr8 ptrBuf( aBuffer->Des() );

   102         if ( ptrBuf.MaxSize() < size  )

   103             {

   104             delete aBuffer;

   105             aBuffer = NULL;

   106             aBuffer = HBufC8::NewL( size * KTwice );

   107             }        

   108         }

   109     else

   110         {

   111         aBuffer = HBufC8::NewL( size * KTwice );

   112         }

   113     

   114     TPtr8 ptr( aBuffer->Des() );

   115     RDesWriteStream stream( ptr );

   116     CleanupClosePushL( stream );

   117     

   118     const TInt count( aFindStrings.MdcaCount() );    

   119     stream.WriteInt16L( count );

   120     for( TInt i(0); i < count; ++i )

   121         {

   122         stream.WriteInt16L( aFindStrings.MdcaPoint( i ).Length() );

   123         stream.WriteL( aFindStrings.MdcaPoint( i ) );

   124         }

   125     

   126     CleanupStack::PopAndDestroy(); // stream    

   127     }

   128 }

   129 

   130 // ============================ MEMBER FUNCTIONS ============================

   131 

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

   133 // RVPbkSimCntView::RVPbkSimCntView

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

   135 // might leave.

   136 // --------------------------------------------------------------------------

   137 //

   138 EXPORT_C RVPbkSimCntView::RVPbkSimCntView() :

   139         iViewEvent( NULL, 0 ),

   140         iContactPtr( NULL, 0 ),

   141         iMatchingBufferSize( NULL, 0 )

   142     {

   143     }

   144 

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

   146 // RVPbkSimCntView::OpenL

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

   148 //

   149 EXPORT_C void RVPbkSimCntView::OpenL( RVPbkSimStore& aStore, 

   150         const RVPbkSimFieldTypeArray& aSortOrder, 

   151         TVPbkSimViewConstructionPolicy aConstructionPolicy, 

   152         const TDesC& aViewName,

   153         CVPbkSimFieldTypeFilter* aFilter )

   154     {

   155     if ( !aStore.Handle() )

   156         {

   157         User::Leave( KErrArgument );

   158         }

   159 

   160     if ( !iContactBuf )

   161         {

   162         iContactBuf = HBufC8::NewL( KInitialReadBufSize );

   163         iContactPtr.Set( iContactBuf->Des() );

   164         }

   165 

   166     HBufC8* sortOrderbuf = ExternalizeSortOrderLC( aSortOrder );

   167     HBufC8* filterBuf = NULL;

   168     if ( aFilter )

   169         {

   170         filterBuf = aFilter->ExternalizeLC();

   171         }

   172     else

   173         {

   174         CleanupStack::PushL( filterBuf );

   175         }

   176 

   177     HBufC8* ipcPackage =

   178         SerializeParametersL( &aViewName, filterBuf );

   179 	CleanupStack::PushL( ipcPackage );

   180 

   181     User::LeaveIfError( CreateSubSession( aStore, EVPbkSimSrvOpenView, 

   182         TIpcArgs( sortOrderbuf, ipcPackage, aConstructionPolicy ) ) );

   183     //ipcPackage,filterBuf,sortOrderbuf

   184     CleanupStack::PopAndDestroy( 3, sortOrderbuf );

   185     }

   186 

   187 // --------------------------------------------------------------------------

   188 // RVPbkSimCntView::Close

   189 // --------------------------------------------------------------------------

   190 //

   191 EXPORT_C void RVPbkSimCntView::Close()

   192     {

   193     delete iMatchingBuffer;

   194     iMatchingBuffer = NULL;

   195     delete iContactBuf;

   196     iContactBuf = NULL;

   197     CloseSubSession( EVPbkSimSrvCloseView );

   198     }

   199 

   200 // --------------------------------------------------------------------------

   201 // RVPbkSimCntView::CancelAsyncRequest

   202 // --------------------------------------------------------------------------

   203 //

   204 EXPORT_C void RVPbkSimCntView::CancelAsyncRequest( TInt aReqToCancel )

   205     {

   206     TPckg<TInt> opCode( aReqToCancel );

   207     SendReceive( EVPbkSimSrvCancelAsyncRequest, TIpcArgs( &opCode ) );

   208     }

   209 

   210 // --------------------------------------------------------------------------

   211 // RVPbkSimCntView::ListenToViewEvents

   212 // --------------------------------------------------------------------------

   213 //

   214 EXPORT_C void RVPbkSimCntView::ListenToViewEvents( TRequestStatus& aStatus,

   215     TVPbkSimContactEventData& aEvent )

   216     {

   217     TPckg<TVPbkSimContactEventData> pckg( aEvent );

   218     iViewEvent.Set( pckg );

   219     SendReceive( EVPbkSimSrvViewEventNotification, TIpcArgs( &iViewEvent ), 

   220         aStatus );

   221     }

   222 

   223 // --------------------------------------------------------------------------

   224 // RVPbkSimCntView::CountL

   225 // --------------------------------------------------------------------------

   226 //

   227 EXPORT_C TInt RVPbkSimCntView::CountL() const

   228     {

   229     TInt count = KErrNotFound;

   230     TPckg<TInt> pckg( count );

   231     User::LeaveIfError( 

   232         SendReceive( EVPbkSimSrvViewCount, TIpcArgs( &pckg ) ) );

   233     return count;

   234     }

   235 

   236 // --------------------------------------------------------------------------

   237 // RVPbkSimCntView::ContactAtL

   238 // --------------------------------------------------------------------------

   239 //

   240 EXPORT_C TPtr8 RVPbkSimCntView::ContactAtL( TInt aIndex )

   241     {

   242     TInt result = KErrNone;

   243     do

   244         {

   245         result = SendReceive( EVPbkSimSrvGetViewContact, 

   246             TIpcArgs( aIndex, &iContactPtr ) );

   247         if ( result == KErrNone )

   248             {

   249             return iContactPtr;

   250             }

   251         else if ( result == KErrOverflow )

   252             {

   253             EnlargeBufferOrLeaveL();

   254             }

   255         else

   256             {

   257             User::Leave( result );

   258             }

   259         } while ( result == KErrOverflow );

   260         

   261     return iContactPtr;

   262     }

   263 

   264 // --------------------------------------------------------------------------

   265 // RVPbkSimCntView::ChangeSortOrderL

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

   267 //

   268 EXPORT_C void RVPbkSimCntView::ChangeSortOrderL( 

   269     const RVPbkSimFieldTypeArray& aSortOrder )

   270     {

   271     HBufC8* buf = ExternalizeSortOrderLC( aSortOrder );

   272     User::LeaveIfError( SendReceive( EVPbkSimSrvChangeViewSortOrder, 

   273         TIpcArgs( buf ) ) );

   274     CleanupStack::PopAndDestroy( buf );

   275     }

   276 

   277 // --------------------------------------------------------------------------

   278 // RVPbkSimCntView::FindViewIndexL

   279 // --------------------------------------------------------------------------

   280 //

   281 EXPORT_C TInt RVPbkSimCntView::FindViewIndexL( TInt aSimIndex )

   282     {

   283     TInt viewIndex = KErrNotFound;

   284     TPckg<TInt> pckg( viewIndex );

   285     User::LeaveIfError( SendReceive( EVPbkSimSrvFindViewIndex, 

   286         TIpcArgs( aSimIndex, &pckg ) ) );

   287     return viewIndex;

   288     }

   289 

   290 // --------------------------------------------------------------------------

   291 // RVPbkSimCntView::ContactMatchingPrefixL

   292 // --------------------------------------------------------------------------

   293 //

   294 EXPORT_C void RVPbkSimCntView::ContactMatchingPrefixL(

   295         const MDesCArray& aFindStrings,

   296         TInt& aResultBufferSize,

   297         TRequestStatus& aStatus )

   298     {

   299     TPckg<TInt> resultSize( aResultBufferSize );

   300     iMatchingBufferSize.Set( resultSize );     

   301         

   302     ExternalizeFindStringsL( iMatchingBuffer, aFindStrings );

   303     SendReceive( EVPbkSimSrvContactMatchingPrefix, 

   304                  TIpcArgs( iMatchingBuffer, &iMatchingBufferSize ), 

   305                  aStatus ) ;

   306     }

   307 

   308 // --------------------------------------------------------------------------

   309 // RVPbkSimCntView::ContactMatchingResultL

   310 // --------------------------------------------------------------------------

   311 //

   312 EXPORT_C void RVPbkSimCntView::ContactMatchingResultL( 

   313         TPtr8& aSimMatchResultBufPtr )

   314     {

   315     User::LeaveIfError( SendReceive( EVPbkSimSrvContactMathingResult, 

   316         TIpcArgs( &aSimMatchResultBufPtr ) ) );

   317     }

   318 

   319 // --------------------------------------------------------------------------

   320 // RVPbkSimCntView::SortOrderL

   321 // --------------------------------------------------------------------------

   322 //

   323 EXPORT_C HBufC8* RVPbkSimCntView::SortOrderL() const

   324     {

   325     // Use loop because there is too requests and after getting the

   326     // size of the needed buffer it can be that some other client

   327     // changes the sort order before our second request.

   328     HBufC8* sortOrder = NULL;

   329     TInt res = KErrOverflow;

   330     TInt attempts = 0;

   331     while ( res == KErrOverflow && attempts < KMaxSortOrderAttempts )

   332         {

   333         delete sortOrder;

   334         // Get first the size

   335         TInt size = 0;

   336         TPckg<TInt> pckg( size );

   337         User::LeaveIfError( SendReceive( EVPbkSimSrvViewSortOrderSize, 

   338                 TIpcArgs( &pckg ) ) );

   339         // Create a buffer for sort order.

   340         sortOrder = HBufC8::NewL( size );

   341         TPtr8 ptr( sortOrder->Des() );

   342         // Get sort order

   343         res = SendReceive( EVPbkSimSrvViewSortOrder, TIpcArgs( &ptr ) );

   344         ++attempts;

   345         }

   346         

   347     User::LeaveIfError( res );

   348     

   349     return sortOrder;

   350     }

   351     

   352 // --------------------------------------------------------------------------

   353 // RVPbkSimCntView::EnlargeBufferOrLeaveL

   354 // --------------------------------------------------------------------------

   355 //

   356 void RVPbkSimCntView::EnlargeBufferOrLeaveL()

   357     {

   358     TInt newLength = 2 * iContactPtr.MaxLength();

   359     if ( newLength > KMaxReadBufSize )

   360         {

   361         User::Leave( KErrOverflow );

   362         }

   363 

   364     VPbkSimStoreImpl::CheckAndUpdateBufferSizeL( iContactBuf, iContactPtr, 

   365         newLength );

   366     }

   367 

   368 // --------------------------------------------------------------------------

   369 // RVPbkSimCntView::SerializeParametersL

   370 // --------------------------------------------------------------------------

   371 //

   372 inline HBufC8* RVPbkSimCntView::SerializeParametersL(

   373         const TDesC* aViewName, const HBufC8* aFilterBuffer ) const

   374     {

   375     TInt packageLength = 0;

   376 	packageLength += VPbkEngUtils::VPbkIPCPackage::CountPackageSize

   377         ( aViewName );

   378 	packageLength += VPbkEngUtils::VPbkIPCPackage::CountPackageSize

   379         ( aFilterBuffer );

   380 

   381     HBufC8* ipcPackage = HBufC8::NewL( packageLength );

   382     TPtr8 bufferPtr( ipcPackage->Des() );

   383     RDesWriteStream writeStream( bufferPtr  );

   384     writeStream.PushL();

   385 

   386     // Important to externalize everything, even the NULL pointers

   387     VPbkEngUtils::VPbkIPCPackage::ExternalizeL( aViewName, writeStream );

   388     VPbkEngUtils::VPbkIPCPackage::ExternalizeL( aFilterBuffer, writeStream );

   389 

   390     writeStream.CommitL();

   391     

   392     CleanupStack::PopAndDestroy( &writeStream );

   393 

   394     return ipcPackage;

   395     }

   396 

   397 

   398 

   399 //  End of File