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: 

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <EikEnv.h>

    22 #include <barsread.h>

    23 #include <e32math.h>

    24 

    25 #include <alfexcalendar.rsg>

    26 #include "alfexcalendarengine.h"

    27 

    28 // CONSTANTS

    29 const TReal KAlfExCalendarEngineChangeDay = 0.7;

    30 const TReal KAlfExCalendarEngineDayRandomizeLoopCount = 4;

    31 const TReal KAlfExCalendarEngineDayRandomize = 10;

    32 const TReal KAlfExCalendarEngineDayTenDays = 10;

    33 const TReal KAlfExCalendarEngineArrayGranularity = 4;

    34 

    35 // LOCAL CONSTANTS AND MACROS

    36 

    37 // ================= MEMBER FUNCTIONS =======================

    38 

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

    40 // CAlfExCalendarEngine::NewL

    41 // ----------------------------------------------------

    42 CAlfExCalendarEngine* CAlfExCalendarEngine::NewL()

    43     {

    44     CAlfExCalendarEngine* self = CAlfExCalendarEngine::NewLC();

    45     CleanupStack::Pop( self );

    46     return self;

    47     }

    48     

    49     

    50 // ----------------------------------------------------

    51 // CAlfExCalendarEngine::NewLC

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

    53 CAlfExCalendarEngine* CAlfExCalendarEngine::NewLC()

    54     {

    55     CAlfExCalendarEngine* self = new (ELeave) CAlfExCalendarEngine();

    56     CleanupStack::PushL( self );

    57     self->ConstructL();

    58     return self;

    59     }

    60     

    61     

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

    63 // CAlfExCalendarEngine::CAlfExCalendarEngine

    64 // ----------------------------------------------------

    65 CAlfExCalendarEngine::CAlfExCalendarEngine()

    66     {

    67     iCalendarEventArray.Reset();

    68     }

    69 

    70     

    71 // ----------------------------------------------------

    72 // CAlfExCalendarEngine::ConstructL

    73 // ----------------------------------------------------

    74 void CAlfExCalendarEngine::ConstructL()

    75     {

    76     TReal   randomNumber;

    77     TInt    randomNumberInt;

    78     TInt64  seed=0;

    79     

    80     CDesCArrayFlat* array = new(ELeave) CDesCArrayFlat(KAlfExCalendarEngineArrayGranularity);

    81     CleanupStack::PushL( array );

    82     

    83     CEikonEnv* coeEnv = CEikonEnv::Static();

    84     TResourceReader reader;

    85     coeEnv->CreateResourceReaderLC(reader, R_ALFEXCALENDAR_CALENDAR_EVENTS_ARRAY);

    86     

    87     const TInt count = reader.ReadInt16();

    88     for(TInt loop = 0; loop < count; loop++)

    89         {

    90         HBufC* txt = reader.ReadHBufCL();

    91         CleanupStack::PushL(txt);

    92         array->AppendL(*txt);

    93         CleanupStack::PopAndDestroy(txt);

    94         }

    95     CleanupStack::PopAndDestroy(); //reader2

    96 

    97     TAlfExCalendarEngineListItem event;

    98     event.iItemDay.HomeTime();

    99     seed = event.iItemDay.Int64();

   100     randomNumber = count * Math::FRand(seed);

   101     randomNumberInt = (TInt) randomNumber;

   102     

   103     TTimeIntervalDays days(KAlfExCalendarEngineDayTenDays);

   104     event.iItemDay -= days; // lets start 10 days before present

   105     

   106     for(TInt i=0; i<KAlfExCalendarEngineDayRandomizeLoopCount; i++)

   107         {

   108         for(TInt loop = 0; loop < count; loop++)

   109             {

   110             randomNumber = Math::FRand(seed);

   111             if(randomNumber < KAlfExCalendarEngineChangeDay)

   112                 {

   113                 randomNumber *= KAlfExCalendarEngineDayRandomize;

   114                 randomNumberInt = (TInt) randomNumber;

   115                 days = TTimeIntervalDays(randomNumberInt);

   116                 event.iItemDay += days;

   117                 }

   118             event.iItemText.Copy((*array)[loop]);

   119             iCalendarEventArray.AppendL(event);

   120             }

   121         }

   122     CleanupStack::PopAndDestroy(array);

   123     }

   124 

   125     

   126 // ----------------------------------------------------

   127 // CAlfExCalendarEngine::~CAlfExCalendarEngine

   128 // ----------------------------------------------------

   129 CAlfExCalendarEngine::~CAlfExCalendarEngine()

   130     {

   131     iCalendarEventArray.Close();

   132     }

   133 

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

   135 // CAlfExCalendarEngine::LoadCalendarEventsL

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

   137 void CAlfExCalendarEngine::LoadCalendarEventsL( const TTime& aDate )

   138     {

   139     TReal   randomNumber;

   140     TInt    randomNumberInt;

   141     TInt64  seed=0;

   142     

   143     CDesCArrayFlat* array = new(ELeave) CDesCArrayFlat(KAlfExCalendarEngineArrayGranularity);

   144     CleanupStack::PushL( array );

   145     

   146     CEikonEnv* coeEnv = CEikonEnv::Static();

   147     TResourceReader reader;

   148     coeEnv->CreateResourceReaderLC(reader, R_ALFEXCALENDAR_CALENDAR_EVENTS_ARRAY);

   149     

   150     const TInt count = reader.ReadInt16();

   151     for(TInt loop = 0; loop < count; loop++)

   152         {

   153         HBufC* txt = reader.ReadHBufCL();

   154         CleanupStack::PushL(txt);

   155         array->AppendL(*txt);

   156         CleanupStack::PopAndDestroy(txt);

   157         }

   158     CleanupStack::PopAndDestroy(); //reader2

   159 

   160     TAlfExCalendarEngineListItem event;

   161     event.iItemDay = aDate; //.HomeTime();

   162     seed = event.iItemDay.Int64();

   163     randomNumber = count * Math::FRand(seed);

   164     randomNumberInt = (TInt) randomNumber;

   165     

   166     TTimeIntervalDays days(KAlfExCalendarEngineDayTenDays);

   167     event.iItemDay -= days; // lets start 10 days before present

   168     

   169     for(TInt i=0; i<KAlfExCalendarEngineDayRandomizeLoopCount; i++)

   170         {

   171         for(TInt loop = 0; loop < count; loop++)

   172             {

   173             randomNumber = Math::FRand(seed);

   174             if(randomNumber < KAlfExCalendarEngineChangeDay)

   175                 {

   176                 randomNumber *= KAlfExCalendarEngineDayRandomize;

   177                 randomNumberInt = (TInt) randomNumber;

   178                 days = TTimeIntervalDays(randomNumberInt);

   179                 event.iItemDay += days;

   180                 }

   181             event.iItemText.Copy((*array)[loop]);

   182             iCalendarEventArray.AppendL(event);

   183             }

   184         }

   185     CleanupStack::PopAndDestroy(array);

   186     }

   187 

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

   189 // CAlfExCalendarEngine::EventsAvailable

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

   191 TBool CAlfExCalendarEngine::EventsAvailable(const TTime& aDate)

   192     {

   193     TBool ret( EFalse );

   194     TDateTime requestedDate = aDate.DateTime();

   195     const TInt arrayCount = iCalendarEventArray.Count();

   196     for(TInt loop = 0; loop < arrayCount; loop++)

   197         {

   198         TDateTime eventDate = iCalendarEventArray[loop].iItemDay.DateTime();

   199         if(eventDate.Day() == requestedDate.Day() && 

   200            eventDate.Month() == requestedDate.Month() &&

   201            eventDate.Year() == requestedDate.Year())

   202             {

   203             ret = ETrue;

   204             break;

   205             }

   206         }

   207     return ret;

   208     }

   209 

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

   211 // CAlfExCalendarEngine::NumberOfEvents

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

   213 TInt CAlfExCalendarEngine::NumberOfEvents(const TTime& aDate)

   214     {

   215     TInt count = 0;

   216     TDateTime requestedDate = aDate.DateTime();

   217     const TInt arrayCount = iCalendarEventArray.Count();

   218     for(TInt loop = 0; loop < arrayCount; loop++)

   219         {

   220         TDateTime eventDate = iCalendarEventArray[loop].iItemDay.DateTime();

   221         if(eventDate.Day() == requestedDate.Day() && 

   222            eventDate.Month() == requestedDate.Month() &&

   223            eventDate.Year() == requestedDate.Year())

   224             {

   225             count++;

   226             }

   227         }

   228     return count;

   229     }

   230 

   231     

   232 // ----------------------------------------------------

   233 // CAlfExCalendarEngine::NumberOfEvents

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

   235 void CAlfExCalendarEngine::GetEventInformation( 

   236     const TTime& aDate, 

   237     TInt aIndex, 

   238     TDes& aTextBuffer)

   239     {

   240     aTextBuffer.Zero();

   241     TInt count = KErrNotFound;

   242     TDateTime requestedDate = aDate.DateTime();

   243     const TInt arrayCount = iCalendarEventArray.Count();

   244     for(TInt loop = 0; loop < arrayCount; loop++ )

   245         {

   246         TDateTime eventDate = iCalendarEventArray[loop].iItemDay.DateTime();

   247         if(eventDate.Day() == requestedDate.Day() && 

   248            eventDate.Month() == requestedDate.Month() &&

   249            eventDate.Year() == requestedDate.Year())

   250             {

   251             count++;

   252             }

   253         if(aIndex == count)

   254             {

   255             aTextBuffer.Copy(iCalendarEventArray[loop].iItemText);

   256             loop = arrayCount;

   257             }

   258         }

   259     }

   260     

   261     

   262 // end of file