1 /*

     2 * Copyright (c) 2002 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: 

    15 *       Provides methods for Generic Phonebook view state.

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES

    21 #include "CPbkViewState.h"

    22 #include <s32mem.h>

    23 #include "PbkUID.h"

    24 #include <CPbkFieldData.h>

    25 

    26 /// Unnamed namespace for local definitions

    27 namespace {

    28 

    29 // LOCAL CONSTANTS AND MACROS

    30 enum TPanicCode

    31     { 

    32     EPanicInvalidDataType = 1,

    33     EPanicInvalidMarkedContactCount

    34     };

    35 

    36 void Panic(TPanicCode aReason)

    37     {

    38     _LIT(KPanicText, "CPbkViewState");

    39     User::Panic(KPanicText, aReason);

    40     }

    41 } // namespace

    42 

    43 // CONSTANTS

    44 const TUid CPbkViewState::KUid = { KPbkViewStateUid };

    45 

    46 

    47 // MODULE DATA STRUCTURES

    48 

    49 /**

    50  * Stream buffer which counts number of bytes written to it.

    51  */

    52 NONSHARABLE_CLASS(TCalcLengthStreamBuf) : 

    53         public MStreamBuf

    54     {

    55     public:  // Interface

    56 		/**

    57 		 * Constructor.

    58 		 */

    59         inline TCalcLengthStreamBuf()

    60             : iBytesWritten(0)

    61             {

    62             }

    63 

    64 		/**

    65 		 * Returns the number bytes written.

    66 		 */

    67         inline TInt BytesWritten() const

    68             {

    69             return iBytesWritten;

    70             }

    71 

    72 		/**

    73 		 * Resets the bytes written count.

    74 		 */

    75         inline void Reset()

    76             {

    77             iBytesWritten = 0;

    78             }

    79 

    80     private:  // from MStreamBuf

    81 	    void DoWriteL(const TAny* /*aPtr*/,TInt aLength)

    82             {

    83             // Just count the bytes

    84             iBytesWritten += aLength;

    85             }

    86 

    87     private:  // Data

    88         /// Ref: count of bytes written to this streambuf

    89         TInt iBytesWritten;

    90     };

    91 

    92 

    93 // ================= MEMBER FUNCTIONS =======================

    94 

    95 EXPORT_C CPbkViewState* CPbkViewState::NewL()

    96     {

    97     CPbkViewState* self = new(ELeave) CPbkViewState;

    98     return self;

    99     }

   100 

   101 EXPORT_C CPbkViewState* CPbkViewState::NewLC()

   102     {

   103     CPbkViewState* self = new(ELeave) CPbkViewState;

   104     CleanupStack::PushL(self);

   105     return self;

   106     }

   107 

   108 EXPORT_C CPbkViewState* CPbkViewState::NewL(RReadStream& aStream)

   109     {

   110     CPbkViewState* self = CPbkViewState::NewLC(aStream);

   111     CleanupStack::Pop();  // self

   112     return self;

   113     }

   114 

   115 EXPORT_C CPbkViewState* CPbkViewState::NewLC(RReadStream& aStream)

   116     {

   117     CPbkViewState* self = new(ELeave) CPbkViewState;

   118     CleanupStack::PushL(self);

   119     self->InternalizeL(aStream);

   120     return self;

   121     }

   122 

   123 EXPORT_C CPbkViewState* CPbkViewState::NewL(const TDesC8& aBuf)

   124     {

   125     CPbkViewState* self = CPbkViewState::NewLC(aBuf);

   126     CleanupStack::Pop();  // self

   127     return self;

   128     }

   129 

   130 EXPORT_C CPbkViewState* CPbkViewState::NewLC(const TDesC8& aBuf)

   131     {

   132     CPbkViewState* self = new(ELeave) CPbkViewState;

   133     CleanupStack::PushL(self);

   134     self->UnpackL(aBuf);

   135     return self;

   136     }

   137 

   138 CPbkViewState::~CPbkViewState()

   139     {

   140     delete iMarkedContactIds;

   141     if (iFieldDataArray)

   142         {

   143         iFieldDataArray->ResetAndDestroy();

   144         delete iFieldDataArray;

   145         }

   146     }

   147 

   148 EXPORT_C TUid CPbkViewState::Uid()

   149     {

   150     return KUid;

   151     }

   152 

   153 EXPORT_C TContactItemId CPbkViewState::FocusedContactId() const 

   154     { 

   155     return iFocusedContactId; 

   156     }

   157 

   158 EXPORT_C TContactItemId CPbkViewState::TopContactId() const 

   159     { 

   160     return iTopContactId; 

   161     }

   162 

   163 EXPORT_C const CContactIdArray* CPbkViewState::MarkedContactIds() const 

   164     { 

   165     return iMarkedContactIds; 

   166     }

   167 

   168 EXPORT_C CContactIdArray* CPbkViewState::MarkedContactIds() 

   169     { 

   170     return iMarkedContactIds; 

   171     }

   172 

   173 EXPORT_C TInt CPbkViewState::FocusedFieldIndex() const 

   174     { 

   175     return iFocusedFieldIndex; 

   176     }

   177 

   178 EXPORT_C TInt CPbkViewState::TopFieldIndex() const 

   179     { 

   180     return iTopFieldIndex; 

   181     }

   182 

   183 EXPORT_C CPbkFieldDataArray* CPbkViewState::FieldDataArray() const 

   184     { 

   185     return iFieldDataArray; 

   186     }

   187 

   188 EXPORT_C TContactItemId CPbkViewState::ParentContactId() const

   189     {

   190     return iParentContactId;

   191     }

   192 

   193 EXPORT_C TUint CPbkViewState::Flags() const

   194     {

   195     return iFlags;

   196     }

   197 

   198 EXPORT_C void CPbkViewState::SetFocusedContactId(TContactItemId aId) 

   199     { 

   200     iFocusedContactId=aId; 

   201     }

   202 

   203 EXPORT_C void CPbkViewState::SetTopContactId(TContactItemId aId) 

   204     { 

   205     iTopContactId=aId; 

   206     }

   207 

   208 EXPORT_C void CPbkViewState::SetMarkedContactIds(CContactIdArray* aArray)

   209     {

   210     delete iMarkedContactIds;

   211     iMarkedContactIds = aArray;

   212     }

   213 

   214 EXPORT_C void CPbkViewState::SetFocusedFieldIndex(TInt aIndex) 

   215     { 

   216     iFocusedFieldIndex=aIndex; 

   217     }

   218 

   219 EXPORT_C void CPbkViewState::SetTopFieldIndex(TInt aIndex) 

   220     { 

   221     iTopFieldIndex=aIndex; 

   222     }

   223 

   224 EXPORT_C void CPbkViewState::SetFieldDataArray

   225         (CPbkFieldDataArray* aFieldDataArray)

   226     {

   227     if (iFieldDataArray)

   228         {

   229         iFieldDataArray->ResetAndDestroy();

   230         delete iFieldDataArray;

   231         }

   232     iFieldDataArray = aFieldDataArray;

   233     }

   234 

   235 EXPORT_C void CPbkViewState::Reset()

   236     {

   237     iFocusedContactId = KNullContactId;

   238     iTopContactId = KNullContactId;

   239     iFocusedFieldIndex = -1;

   240     iTopFieldIndex = -1;

   241     delete iMarkedContactIds;

   242     iMarkedContactIds = NULL;

   243     if (iFieldDataArray)

   244         {

   245         iFieldDataArray->ResetAndDestroy();

   246         delete iFieldDataArray;

   247         iFieldDataArray = NULL;

   248         }

   249     iParentContactId = KNullContactId;

   250     }

   251 

   252 EXPORT_C void CPbkViewState::SetParentContactId

   253         (TContactItemId aParentContactId)

   254     {

   255     iParentContactId = aParentContactId;

   256     }

   257 

   258 EXPORT_C void CPbkViewState::SetFlags

   259         (TUint aFlags)

   260     {

   261     iFlags = aFlags;

   262     }

   263 

   264 /*EXPORT_C*/ void CPbkViewState::MergeViewState(CPbkViewState& aOtherState)

   265     {

   266     if (aOtherState.iFocusedContactId != KNullContactId)

   267         {

   268         iFocusedContactId = aOtherState.iFocusedContactId;

   269         }

   270     if (aOtherState.iTopContactId != KNullContactId)

   271         {

   272         iTopContactId = aOtherState.iTopContactId;

   273         }

   274     if (aOtherState.iFocusedFieldIndex >= 0)

   275         {

   276         iFocusedFieldIndex = aOtherState.iFocusedFieldIndex;

   277         }

   278     if (aOtherState.iTopFieldIndex >= 0)

   279         {

   280         iTopFieldIndex = aOtherState.iTopFieldIndex;

   281         }

   282     if (aOtherState.iMarkedContactIds && aOtherState.iMarkedContactIds->Count() > 0)

   283         {

   284         delete iMarkedContactIds;

   285         iMarkedContactIds = aOtherState.iMarkedContactIds;

   286         aOtherState.iMarkedContactIds = NULL;

   287         }

   288     if (aOtherState.iFieldDataArray && aOtherState.iFieldDataArray->Count() > 0)

   289         {

   290         delete iFieldDataArray;

   291         iFieldDataArray = aOtherState.iFieldDataArray;

   292         aOtherState.iFieldDataArray = NULL;

   293         }

   294     if (aOtherState.iParentContactId != KNullContactId)

   295         {

   296         iParentContactId = aOtherState.iParentContactId;

   297         }

   298     }

   299 

   300 EXPORT_C HBufC8* CPbkViewState::PackL() const

   301     {

   302     HBufC8* buf = PackLC();

   303     CleanupStack::Pop();  // buf

   304     return buf;

   305     }

   306 

   307 EXPORT_C HBufC8* CPbkViewState::PackLC() const

   308     {

   309     // Calculate needed buffer size using TCalcLengthStreamBuf

   310     TCalcLengthStreamBuf countBuf;

   311         {

   312         RWriteStream countStream(&countBuf);

   313         // this can't leave because we are using TCalcLengthStreamBuf

   314         ExternalizeL(countStream); 

   315         }

   316 

   317     // Allocate a buffer and a stream

   318     HBufC8* buf = HBufC8::NewLC(countBuf.BytesWritten());

   319     TPtr8 bufPtr = buf->Des();

   320     RDesWriteStream stream(bufPtr);

   321     stream.PushL();

   322 

   323     // Write this object to buf through stream

   324     ExternalizeL(stream);

   325 

   326     stream.CommitL();

   327     CleanupStack::PopAndDestroy();  // stream

   328     return buf;

   329     }

   330 

   331 EXPORT_C void CPbkViewState::UnpackL(const TDesC8& aPack)

   332     {

   333     RDesReadStream stream(aPack);

   334     stream.PushL();

   335     InternalizeL(stream);

   336     CleanupStack::PopAndDestroy();  // stream

   337     }

   338 

   339 EXPORT_C void CPbkViewState::ExternalizeL(RWriteStream& aStream) const

   340     {

   341     if (iFocusedContactId != KNullContactId)

   342         {

   343         aStream.WriteInt8L(EFocusedContactId);

   344         aStream.WriteInt32L(iFocusedContactId);

   345         }

   346 

   347     if (iTopContactId != KNullContactId)

   348         {

   349         aStream.WriteInt8L(ETopContactId);

   350         aStream.WriteInt32L(iTopContactId);

   351         }

   352 

   353     const TInt count = iMarkedContactIds ? iMarkedContactIds->Count() : 0;

   354     if (count > 0)

   355         {

   356         aStream.WriteInt8L(EMarkedContactIds);

   357         aStream.WriteInt32L(count);

   358         for (TInt i=0; i < count; ++i)

   359             {

   360             aStream.WriteInt32L((*iMarkedContactIds)[i]);

   361             }

   362         }

   363 

   364     if (iFocusedFieldIndex >= 0)

   365         {

   366         aStream.WriteInt8L(EFocusedFieldIndex);

   367         aStream.WriteInt32L(iFocusedFieldIndex);

   368         }

   369 

   370     if (iTopFieldIndex >= 0)

   371         {

   372         aStream.WriteInt8L(ETopFieldIndex);

   373         aStream.WriteInt32L(iTopFieldIndex);

   374         }

   375 

   376     if (iFieldDataArray && iFieldDataArray->Count() > 0)

   377         {

   378         aStream.WriteInt8L(EFieldDataArray);

   379         iFieldDataArray->ExternalizeL(aStream);

   380         }

   381 

   382     if (iParentContactId != KNullContactId)

   383         {

   384         aStream.WriteInt8L(EParentContactId);

   385         aStream.WriteInt32L(iParentContactId);

   386         }

   387 

   388     if (iFlags != ENullFlags)

   389         {

   390         aStream.WriteInt8L(EFlags);

   391         aStream.WriteUint32L(iFlags);

   392         }

   393 

   394     aStream.WriteInt8L(EEnd);

   395     }

   396 

   397 EXPORT_C void CPbkViewState::InternalizeL(RReadStream& aStream)

   398     {

   399     Reset();

   400 

   401     TBool eof = EFalse;

   402     while (!eof)

   403         {

   404         TInt type = EEnd;

   405         TRAPD(err, type = aStream.ReadInt8L());

   406         switch (err)

   407             {

   408             case KErrEof:

   409 				{

   410                 // End of stream, exit loop like EEnd opcode was read.

   411                 type = EEnd;

   412                 break;

   413 				}

   414             case KErrNone:

   415 				{

   416                 break;

   417 				}

   418             default:

   419 				{

   420                 // Some other error than EOF occured.

   421                 User::Leave(err);

   422                 break;

   423 				}

   424             }

   425 

   426         switch (type)

   427             {

   428             case EFocusedContactId:

   429 				{

   430                 iFocusedContactId = aStream.ReadInt32L();

   431                 break;

   432 				}

   433 

   434             case ETopContactId:

   435 				{

   436                 iTopContactId = aStream.ReadInt32L();

   437                 break;

   438 				}

   439 

   440             case EMarkedContactIds:

   441                 {

   442                 TInt count = aStream.ReadInt32L();

   443                 __ASSERT_ALWAYS(count > 0, Panic(EPanicInvalidMarkedContactCount));

   444                 iMarkedContactIds = CContactIdArray::NewL();

   445                 while (count-- > 0)

   446                     {

   447                     iMarkedContactIds->AddL(aStream.ReadInt32L());

   448                     }

   449                 break;

   450                 }

   451 

   452             case EFocusedFieldIndex:

   453 				{

   454                 iFocusedFieldIndex = aStream.ReadInt32L();

   455                 break;

   456 				}

   457 

   458             case ETopFieldIndex:

   459 				{

   460                 iTopFieldIndex = aStream.ReadInt32L();

   461                 break;

   462 				}

   463 

   464             case EFieldDataArray:

   465 				{

   466                 iFieldDataArray = CPbkFieldDataArray::NewL(aStream);

   467                 break;

   468 				}

   469             case EParentContactId:

   470                 {

   471                 iParentContactId = aStream.ReadInt32L();

   472                 break;

   473                 }

   474 

   475             case EFlags:

   476                 {

   477                 iFlags = aStream.ReadUint32L();

   478                 break;

   479                 }

   480 

   481             case EEnd:

   482 				{

   483                 eof = ETrue;

   484                 break;

   485 				}

   486 

   487             default:

   488 				{

   489                 Panic(EPanicInvalidDataType);

   490                 break;

   491 				}

   492             }

   493         }

   494     }

   495 

   496 EXPORT_C TBool CPbkViewState::operator==(const CPbkViewState& aRhs) const

   497     {

   498     return iFocusedContactId == aRhs.iFocusedContactId &&

   499             iTopContactId == aRhs.iTopContactId &&

   500             iFocusedFieldIndex == aRhs.iFocusedFieldIndex &&

   501             iTopFieldIndex == aRhs.iTopFieldIndex &&

   502             iParentContactId == aRhs.iParentContactId; 

   503     }

   504 

   505 /**

   506  * C++ default constructor.

   507  */

   508 CPbkViewState::CPbkViewState() :

   509     iFocusedContactId(KNullContactId),

   510     iTopContactId(KNullContactId),

   511     iFocusedFieldIndex(-1),

   512     iTopFieldIndex(-1),

   513     iMarkedContactIds(NULL),

   514     iFieldDataArray(NULL),

   515     iParentContactId(KNullContactId)

   516     {

   517     }

   518 

   519 

   520 //  End of File