1 /*

     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Client-Server communication

    15 *

    16 */

    17 

    18 

    19 #include <e32std.h>

    20 #include <s32strm.h>

    21 #include <s32mem.h>

    22 

    23 #include "lbt.h"

    24 #include "lbtserver.h"

    25 #include "lbttriggerinfo.h"

    26 #include "lbterrors.h"

    27 #include "lbtserverconsts.h"

    28 #include "lbtsessiontrigger.h"

    29 #include "lbtstartuptrigger.h"

    30 #include "lbtclientrequester.h"

    31 #include "lbtlisttriggeroptions.h"

    32 #include "lbttriggerfilterbase.h"

    33 #include "lbttriggerinfo.h"

    34 #include "lbttriggerfilterbyattribute.h"

    35 #include "lbttriggerconditionarea.h"

    36 #include "lbtserverconsts.h"

    37 #include "lbttriggeringsystemmanagementsettings.h"

    38 #include "lbttriggerfilterbyarea.h"

    39 #include "lbtgeocircle.h"

    40 #include "lbtgeocell.h"

    41 #include "lbtgeohybrid.h"

    42 #include "lbtterminalptrholder.h"

    43 

    44 // ---------------------------------------------------------------------------

    45 // RLbt::RLbt()

    46 //

    47 // Default constructor.

    48 // ---------------------------------------------------------------------------

    49 // 

    50 EXPORT_C RLbt::RLbt()

    51     { // Handling of these functions need to be discussed.

    52 	TRAP_IGNORE(iPtrHolder = CLbtSubSessnPtrHolder::NewL(10, 10));

    53 	TRAP_IGNORE(iClientRequester=CLbtClientRequester::NewL( *this ));

    54 	TRAP_IGNORE(iTriggerCreationInfo=new( ELeave)TLbtTriggerCreationInfo);

    55 	TRAP_IGNORE(iTriggerStateInfo = new( ELeave ) TLbtTriggerStateInfo);

    56 	TRAP_IGNORE(iTriggerUpdationInfo = new( ELeave ) TLbtTriggerUpdationInfo);

    57 	}

    58 

    59 // ---------------------------------------------------------------------------

    60 // RLbt::~RLbt

    61 //

    62 // Destructor.

    63 // ---------------------------------------------------------------------------

    64 // 	

    65 EXPORT_C RLbt::~RLbt()

    66     {

    67     if(iPtrHolder)

    68         {

    69         delete iPtrHolder;

    70         iPtrHolder = NULL;

    71 				}

    72     if(iClientRequester)

    73         {

    74         delete iClientRequester;

    75         iClientRequester = NULL;

    76         }

    77     if(iTriggerCreationInfo)    

    78     	{

    79     	delete iTriggerCreationInfo; 

    80      	iTriggerCreationInfo=NULL; 

    81     	} 

    82     if( iTriggerUpdationInfo )

    83         {

    84         delete iTriggerUpdationInfo;

    85         iTriggerUpdationInfo = NULL;

    86         }

    87     if( iTriggerStateInfo )

    88         {

    89         delete iTriggerStateInfo;

    90         iTriggerStateInfo = NULL;

    91         }

    92     iTriggerList.Close();	

    93     }

    94 

    95 

    96 // ---------------------------------------------------------------------------

    97 // RLbt::ConstructL

    98 //Symbian 2nd phase constructor can leave.

    99 // ---------------------------------------------------------------------------

   100 //     

   101 void RLbt::ConstructL()

   102     {

   103     iCreateIteratorFlag=EFalse;

   104     }

   105 

   106 

   107 // ---------------------------------------------------------

   108 // RLbt::Open

   109 //

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

   111 // ---------------------------------------------------------

   112 //

   113 EXPORT_C TInt RLbt::Open( RLbtServer& aServer )

   114     {

   115     __ASSERT_ALWAYS(aServer.Handle() != 0,

   116 		User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   117 		

   118 	__ASSERT_ALWAYS(! SubSessionHandle() , User::Panic  (KLbtClientPanicCategory, ELbtServerBadHandle));

   119 	TRAPD(ret, ConstructL());

   120 	if (ret == KErrNone)

   121 		{

   122 		ret = CreateSubSession(aServer, ELbtSubSessionOpen, TIpcArgs());

   123 		}

   124 

   125 	return ret;     

   126     }

   127 

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

   129 // RLbt::Open

   130 //

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

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

   133 //

   134 EXPORT_C TInt RLbt::Open()

   135     {

   136     return 0;	

   137     }   

   138 

   139 // ---------------------------------------------------------

   140 // RLbt::Close

   141 //

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

   143 // ---------------------------------------------------------

   144 //

   145 EXPORT_C void RLbt:: Close()

   146     {

   147     TBool isActive = iClientRequester-> IsActive();

   148     TInt status = iClientRequester->iStatus.Int();

   149 	if(SubSessionHandle())

   150 	    {

   151     	CloseSubSession(ELbtSubSessionClose);

   152 	    }

   153 	if( isActive && status == KRequestPending )

   154 	    {

   155 	    User::Panic(KLbtClientPanicCategory, ELbtRequestsNotCancelled );

   156 	    }

   157     }

   158 

   159 // ---------------------------------------------------------

   160 // RLbt::CreateTrigger

   161 //

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

   163 // ---------------------------------------------------------

   164 //

   165 EXPORT_C void RLbt:: CreateTrigger( 

   166             const CLbtTriggerEntry& aTrigger,

   167             TLbtTriggerId& aTriggerId,

   168             TBool aFireOnCreation,

   169             TRequestStatus& aStatus )

   170             

   171     {

   172     TRAPD( error, CreateTriggerL( aTrigger,aTriggerId,aFireOnCreation,aStatus ));

   173     if( KErrNone != error )

   174     	{

   175     	TRequestStatus* status = &aStatus;

   176     	User::RequestComplete(status,error);

   177     	}

   178     }

   179 

   180 // ---------------------------------------------------------

   181 // RLbt::CreateTriggerL

   182 //

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

   184 // ---------------------------------------------------------

   185 //

   186 void RLbt:: CreateTriggerL( 

   187             const CLbtTriggerEntry& aTrigger,

   188             TLbtTriggerId& aTriggerId,

   189             TBool aFireOnCreation,

   190             TRequestStatus& aStatus )

   191     {

   192 	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   193 	

   194     aStatus=KRequestPending;

   195 	TRequestStatus* status=&aStatus;

   196 	if(iClientRequester->IsActive())

   197 		User::Panic(KLbtClientPanicCategory, ELbtDuplicateRequest);

   198 	

   199 	if(aTrigger.GetCondition()==NULL || 

   200 	   aTrigger.Name()==KNullDesC)

   201 	    {

   202 	    User::RequestComplete(status,KErrArgument);

   203 	    return;

   204 	    }

   205 	

   206 	RRequestorStack requestors;

   207 	aTrigger.GetRequestorsL( requestors );

   208 	TInt count = requestors.Count();

   209 	requestors.ResetAndDestroy();

   210 	

   211 	if( !count )

   212 	    {

   213 	    User::Leave( KErrAccessDenied );

   214 	    }

   215 	

   216 	if(aTrigger.Type()==CLbtTriggerEntry::ETypeStartup)

   217 		{

   218 		TBuf<256> fileName;

   219     	TSecureId secureId;

   220     	

   221     	const CLbtStartupTrigger* trigger=static_cast<const CLbtStartupTrigger*>

   222     							(&aTrigger);

   223     	trigger->GetProcessId(fileName,secureId);

   224     	if(fileName.Length()==0)

   225     		{

   226 			User::RequestComplete(status,KErrArgument);

   227 	    	return;    		

   228     		}

   229 		}

   230 

   231     const CLbtTriggerConditionArea* cond =static_cast<const CLbtTriggerConditionArea*>( aTrigger.GetCondition()	);

   232     

   233      CLbtGeoAreaBase* area = cond->TriggerArea();

   234 	if(!area)

   235 	    {

   236 	    if(aStatus.Int()== KRequestPending)

   237 	        {

   238 	        User::RequestComplete(status,KErrArgument);

   239 	        }

   240 	    return;    

   241 	    }

   242 	

   243 	ValidateGeoAreaInformationL( area );

   244 	

   245 	if( area->Type() == CLbtGeoAreaBase::ECellular || area->Type() == CLbtGeoAreaBase::EHybrid )

   246         {        

   247         // In the current version of LBT, we dont support EXIT type cell/WLAN based triggers

   248         if( cond->Direction() == CLbtTriggerConditionArea::EFireOnExit )

   249             {

   250             User::RequestComplete( status,KErrNotSupported );

   251             return;

   252             }

   253         }

   254 	

   255 	TIpcArgs args;

   256 	CBufFlat* buffer=NULL;

   257 	RBufWriteStream writeStream;

   258 	

   259 	buffer = CBufFlat::NewL(512);

   260 	CleanupStack::PushL(buffer);

   261 	writeStream.Open(*buffer);

   262 	CleanupClosePushL(writeStream);

   263 	writeStream << aTrigger;

   264 	writeStream.CommitL();

   265 	CleanupStack::PopAndDestroy(&writeStream);

   266     

   267 	TPtr8 ptr = buffer->Ptr(0);

   268 	iPtrHolder->Ptr(0).Set(

   269 		reinterpret_cast<TUint8*>(&aTriggerId),

   270 		sizeof(aTriggerId),sizeof(aTriggerId));

   271 	iPtrHolder->Ptr(1).Set(ptr);	

   272 	

   273 	iTriggerCreationInfo->iFireOnCreation=aFireOnCreation;

   274 	iTriggerCreationInfo->iTriggerType=aTrigger.Type();

   275 	

   276 				

   277 	iPtrHolder->Ptr(2).Set(reinterpret_cast<TUint8*>(iTriggerCreationInfo),

   278 	sizeof(TLbtTriggerCreationInfo),sizeof(TLbtTriggerCreationInfo));	

   279 	iClientRequester->SetStatus(aStatus);

   280 	iClientRequester->SetBuffer(buffer);

   281 	CleanupStack::Pop(buffer);

   282 	

   283 	args.Set(0,&iPtrHolder->Ptr(0));

   284 	args.Set(1,&iPtrHolder->Ptr(1));

   285 	args.Set(2,&iPtrHolder->Ptr(2));

   286 

   287 	

   288 	SendReceive(ELbtCreateTrigger, args, iClientRequester->iStatus );

   289 	iClientRequester->Start();

   290 	}

   291 

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

   293 // RLbt::CancelCreateTrigger

   294 //

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

   296 // ---------------------------------------------------------

   297 //

   298 EXPORT_C void RLbt::CancelCreateTrigger()

   299     {

   300 	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   301 	

   302 	TInt error = SendReceive(ELbtCancelCreateTrigger);

   303 	if( error == KErrNone )

   304 	    {

   305 	    iClientRequester->Cancel();

   306 	    }

   307     }

   308 

   309 // ---------------------------------------------------------

   310 // RLbt::DeleteTriggerL

   311 //

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

   313 // ---------------------------------------------------------

   314 //

   315  EXPORT_C void RLbt::DeleteTriggerL( TLbtTriggerId aId )

   316     {

   317     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   318 		

   319 	TIpcArgs args;

   320 	TPckg<TLbtTriggerId> triggerId(aId);	

   321 	args.Set(0, &triggerId);

   322 	

   323 	User::LeaveIfError(SendReceive(ELbtDeleteTrigger, args));

   324     }

   325 

   326 // ---------------------------------------------------------

   327 // RLbt::DeleteTriggerL

   328 //

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

   330 // ---------------------------------------------------------

   331 //

   332  EXPORT_C void RLbt::DeleteTriggersL( CLbtTriggerFilterBase* aFilter )

   333     {

   334 	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   335 		

   336 	TIpcArgs args;

   337 	CBufFlat* buffer = CBufFlat::NewL(512);	

   338 	CleanupStack::PushL(buffer);

   339 	RBufWriteStream writeStream;

   340 	writeStream.Open(*buffer);

   341 	CleanupClosePushL(writeStream);

   342 	CLbtTriggerFilterBase::TFilterType type;

   343 	

   344 	if(aFilter == NULL)

   345 	    {

   346 	    CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

   347 	    CleanupStack::PushL(filter);

   348 		filter->AddTriggerStateL(CLbtTriggerEntry::EStateEnabled);

   349         filter->AddTriggerStateL(CLbtTriggerEntry::EStateDisabled);

   350         writeStream<< *filter;

   351         type=filter->Type();

   352         CleanupStack::PopAndDestroy(filter);

   353 	    }

   354 	else

   355         {   

   356         if( aFilter->Type() == CLbtTriggerFilterBase::EFilterByArea )

   357             {

   358             CLbtTriggerFilterByArea* areaFilter = static_cast<CLbtTriggerFilterByArea*> ( aFilter );

   359             ValidateGeoAreaInformationL( areaFilter->Area() );

   360             }

   361     	writeStream << *aFilter;

   362     	type=aFilter->Type();

   363         }	 

   364 	

   365 	writeStream.CommitL();

   366 	TPtr8 ptr = buffer->Ptr(0);

   367 

   368 	args.Set(KParamFilterType,type);

   369 	args.Set(KParamFilter,&ptr);

   370 		

   371 	User::LeaveIfError( SendReceive(ELbtDeleteTriggers, args) );

   372     CleanupStack::PopAndDestroy(&writeStream);

   373     CleanupStack::PopAndDestroy(buffer);	

   374     }

   375     

   376 // ---------------------------------------------------------

   377 // RLbt::DeleteTriggers

   378 //

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

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

   381 //

   382 

   383 EXPORT_C void RLbt::DeleteTriggers( TRequestStatus& aStatus,

   384                         CLbtTriggerFilterBase* aFilter )

   385     {

   386     TRAPD( error,DeleteTriggersL( aFilter,aStatus ) );

   387     if( KErrNone != error )

   388     	{

   389     	TRequestStatus* status=&aStatus;

   390     	User::RequestComplete(status,error);

   391     	}

   392     }

   393 

   394 // ---------------------------------------------------------

   395 // RLbt::DeleteTriggersL

   396 //

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

   398 // ---------------------------------------------------------

   399 //

   400 void RLbt::DeleteTriggersL( 

   401             CLbtTriggerFilterBase* aFilter,

   402             TRequestStatus& aStatus )

   403     {

   404     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   405 	

   406 	aStatus = KRequestPending;

   407 

   408 	if(iClientRequester->IsActive())

   409 		User::Panic(KLbtClientPanicCategory, ELbtDuplicateRequest);

   410 	

   411 	TIpcArgs args;

   412 	

   413 	CBufFlat* buffer=NULL;

   414 	RBufWriteStream writeStream;

   415 

   416         buffer = CBufFlat::NewL(512);

   417 	    CleanupStack::PushL(buffer);

   418 	    writeStream.Open(*buffer);

   419 	    CleanupClosePushL(writeStream);

   420 	    

   421 	    CLbtTriggerFilterBase::TFilterType type;

   422 	if(aFilter == NULL)

   423         {

   424         CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

   425         CleanupStack::PushL(filter);

   426     	filter->AddTriggerStateL(CLbtTriggerEntry::EStateEnabled);

   427         filter->AddTriggerStateL(CLbtTriggerEntry::EStateDisabled);

   428         writeStream<< *filter;

   429         type=filter->Type();

   430         CleanupStack::PopAndDestroy(filter);

   431         }

   432 	else

   433         {  

   434         if( aFilter->Type() == CLbtTriggerFilterBase::EFilterByArea )

   435             {

   436             CLbtTriggerFilterByArea* areaFilter = static_cast<CLbtTriggerFilterByArea*> ( aFilter );

   437             ValidateGeoAreaInformationL( areaFilter->Area() );

   438             }

   439     	writeStream << *aFilter;

   440     	type=aFilter->Type();

   441         }	 

   442 	

   443 	  

   444 	writeStream.CommitL();

   445 	CleanupStack::PopAndDestroy(&writeStream);

   446     

   447     TPtr8 ptr = buffer->Ptr(0);

   448 	iPtrHolder->Ptr(0).Set(ptr);

   449 	

   450 	args.Set(KParamFilterType,type);

   451 	args.Set(KParamFilter,&iPtrHolder->Ptr(0));

   452 	

   453 	iClientRequester->SetStatus(aStatus);

   454 	iClientRequester->SetBuffer(buffer);

   455 	CleanupStack::Pop(buffer);

   456 	SendReceive(ELbtDeleteTriggers, args,iClientRequester->iStatus);

   457 	iClientRequester->Start();

   458     }

   459 

   460 // ---------------------------------------------------------

   461 // RLbt::DeleteTriggersL

   462 //

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

   464 // ---------------------------------------------------------

   465 //

   466 EXPORT_C void RLbt::DeleteTriggersL( 

   467             const RArray<TLbtTriggerId> &aTriggerIdList )

   468             

   469     {

   470 	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   471 		

   472 	if(aTriggerIdList.Count()<1)

   473 	    {

   474 	    return;

   475 	    }

   476 	TIpcArgs args;

   477 	TInt i=0;

   478 	CBufFlat* buffer = CBufFlat::NewL(512);	

   479 	CleanupStack::PushL(buffer);

   480 	RBufWriteStream writeStream;

   481 	writeStream.Open(*buffer);

   482 	CleanupClosePushL(writeStream);

   483 	TInt listCount=aTriggerIdList.Count();

   484 	CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

   485 	CleanupStack::PushL(filter);

   486 

   487 	while(i<listCount)

   488 	    {

   489         filter->AddTriggerIdL(aTriggerIdList[i]);

   490         i++;

   491 	    }

   492 	writeStream<<*filter;

   493 	writeStream.CommitL();

   494 

   495 	TPtr8 ptr = buffer->Ptr(0);

   496 

   497 	args.Set(KParamFilterType,filter->Type());

   498 	

   499 	CleanupStack::PopAndDestroy(filter);

   500 	CleanupStack::PopAndDestroy(&writeStream);

   501 	args.Set(KParamFilter,&ptr);

   502 	CleanupStack::Pop(buffer);

   503 	User::LeaveIfError(SendReceive(ELbtDeleteTriggers,args));	

   504 	delete buffer;

   505     }

   506 

   507 // ---------------------------------------------------------

   508 // RLbt::DeleteTriggers

   509 //

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

   511 // ---------------------------------------------------------

   512 //

   513 EXPORT_C void RLbt::DeleteTriggers( 

   514             const RArray<TLbtTriggerId>& aTriggerIdList,

   515             TRequestStatus& aStatus )

   516     {

   517     TRAPD( error,DeleteTriggersL( aTriggerIdList,aStatus ));

   518     if( KErrNone != error )

   519     	{

   520     	TRequestStatus* status=&aStatus;

   521     	User::RequestComplete( status,error );

   522     	}

   523     }

   524 

   525 // ---------------------------------------------------------

   526 // RLbt::DeleteTriggersL

   527 //

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

   529 // ---------------------------------------------------------

   530 //

   531 void RLbt::DeleteTriggersL( 

   532             const RArray<TLbtTriggerId>& aTriggerIdList,

   533             TRequestStatus& aStatus )

   534      {

   535 	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   536 	

   537 	aStatus = KRequestPending;

   538 	TRequestStatus* status=&aStatus;

   539 	if(iClientRequester->IsActive())

   540 		User::Panic(KLbtClientPanicCategory, ELbtDuplicateRequest);

   541 

   542     if(aTriggerIdList.Count()<1)

   543 	    {

   544 	    User::RequestComplete(status,KErrNone);

   545 	    return;

   546 	    }

   547 	TIpcArgs args;

   548 	TInt i=0;

   549 

   550 	

   551 	CBufFlat* buffer=NULL;

   552 	RBufWriteStream writeStream;

   553 

   554 	 buffer = CBufFlat::NewL(512);

   555     CleanupStack::PushL(buffer);

   556     writeStream.Open(*buffer);

   557     CleanupClosePushL(writeStream);

   558 

   559 	

   560     TInt listCount=aTriggerIdList.Count();

   561 	CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

   562 	CleanupStack::PushL(filter);

   563 

   564 	while(i<listCount)

   565 	    {

   566         filter->AddTriggerIdL(aTriggerIdList[i]);

   567 		i++;

   568 	    }

   569 

   570 	writeStream<<*filter;

   571 	writeStream.CommitL();

   572 

   573 	

   574 	TPtr8 ptr = buffer->Ptr(0);

   575 	iClientRequester->SetStatus(aStatus);

   576 	iClientRequester->SetBuffer(buffer);

   577 

   578 		

   579 

   580 	iPtrHolder->Ptr(0).Set(ptr);

   581 	

   582 	args.Set(KParamFilterType,filter->Type());

   583 	

   584 	CleanupStack::PopAndDestroy(filter);

   585 		

   586     CleanupStack::PopAndDestroy(&writeStream);

   587 	

   588 	CleanupStack::Pop(buffer);

   589 	

   590 	args.Set(KParamFilter,&iPtrHolder->Ptr(0));

   591 

   592 	

   593 	SendReceive(ELbtDeleteTriggers,args,iClientRequester->iStatus);

   594 	

   595 	iClientRequester->Start();

   596     }

   597 

   598 // ---------------------------------------------------------

   599 // RLbt::CancelDeleteTriggers

   600 //

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

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

   603 //

   604 EXPORT_C void RLbt::CancelDeleteTriggers()

   605     {

   606 	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   607 	TInt error = SendReceive(ELbtCancelDeleteTriggers);

   608     if( error == KErrNone )

   609         {

   610         iClientRequester->Cancel();

   611         }

   612 	}

   613 

   614 

   615 

   616 // ---------------------------------------------------------

   617 // RLbt::GetTriggerLC

   618 //

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

   620 // ---------------------------------------------------------

   621 //

   622 EXPORT_C CLbtTriggerInfo* RLbt::GetTriggerLC( TLbtTriggerId aId,TLbtTriggerAttributeFieldsMask aEntryFieldMask ,TLbtTriggerDynamicInfoFieldsMask  aDynInfoFieldMask )

   623                 

   624     {

   625     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   626 

   627 	     

   628     CLbtListTriggerOptions* listOptions = CLbtListTriggerOptions::NewL();

   629     CleanupStack::PushL(listOptions);

   630     CLbtTriggerFilterByAttribute* attribFilter = CLbtTriggerFilterByAttribute::NewL();

   631     CleanupStack::PushL(attribFilter);

   632     attribFilter->AddTriggerIdL(aId);

   633     

   634     /* Add attribute Id in the fields to be retirieved. Specified in API*/

   635     TLbtTriggerAttributeFieldsMask entryMask = aEntryFieldMask|CLbtTriggerEntry::EAttributeId;

   636     listOptions->SetRetrievedFields(entryMask,aDynInfoFieldMask);

   637     listOptions->SetFilter(attribFilter);

   638     CBufFlat* buffer = CBufFlat::NewL(512);

   639     CleanupStack::PushL(buffer);

   640     TInt bufLength;

   641     GetTriggersInServerL(buffer,listOptions,bufLength);

   642     RBufReadStream stream(*buffer);

   643     CleanupClosePushL(stream);

   644     /* Neglect the number of triggers in this case, since it has to be one */

   645     TInt numOfTriggers = stream.ReadInt32L();

   646 

   647     CLbtTriggerInfo* triggerInfo = NULL;

   648     if(bufLength>0)

   649         {

   650         triggerInfo = CLbtTriggerInfo::NewL();

   651     	CleanupStack::PushL(triggerInfo);

   652     	triggerInfo->InternalizeL(stream);

   653         CleanupStack::Pop(triggerInfo);

   654         }

   655 

   656     CleanupStack::PopAndDestroy(4); // buffer, stream, 	filter,listoptions

   657     if(triggerInfo)

   658         {

   659         CleanupStack::PushL(triggerInfo); 

   660         }

   661     else

   662         {

   663         User::Leave(KErrNotFound);

   664         }    

   665     return triggerInfo;    

   666     }

   667 

   668 // ---------------------------------------------------------

   669 // RLbt::UpdateTriggerL

   670 //

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

   672 // ---------------------------------------------------------

   673 //

   674 EXPORT_C void RLbt::UpdateTriggerL( const CLbtTriggerEntry& aTrigger,TLbtTriggerAttributeFieldsMask aFieldMask,

   675                                     TLbtFireOnUpdate aFireOnUpdate )

   676     {

   677     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   678 

   679     if(((aFieldMask & CLbtTriggerEntry::EAttributeId) == CLbtTriggerEntry::EAttributeId)||((aFieldMask & CLbtTriggerEntry::EAttributeManagerUi) == CLbtTriggerEntry::EAttributeManagerUi)||((aFieldMask & CLbtTriggerEntry::EAttributeRequestor) == CLbtTriggerEntry::EAttributeRequestor))

   680         {

   681         User::Leave(KErrAccessDenied);

   682         }

   683 

   684 

   685     if(((aFieldMask & CLbtTriggerEntry::EAttributeCondition) == CLbtTriggerEntry::EAttributeCondition))

   686         {

   687         if(aTrigger.GetCondition()==NULL)

   688             {

   689             User::Leave(KErrArgument);

   690             }

   691             

   692         const CLbtTriggerConditionArea* area = static_cast< const CLbtTriggerConditionArea*> (aTrigger.GetCondition());    

   693         if(area->TriggerArea() == NULL)

   694             {

   695             User::Leave(KErrArgument);

   696             }

   697         }

   698     

   699     if(((aFieldMask & CLbtTriggerEntry::EAttributeName) == CLbtTriggerEntry::EAttributeName))

   700         {

   701         if(aTrigger.Name()==KNullDesC || (aTrigger.Name()).Length()>KLbtMaxNameLength)

   702             {

   703             User::Leave(KErrArgument);

   704             }

   705         } 

   706     

   707     if((aFieldMask & CLbtTriggerEntry::EAttributeStartUpProcessId) == CLbtTriggerEntry::EAttributeStartUpProcessId)    

   708         {

   709         User::Leave(KErrAccessDenied);

   710         }

   711            

   712     if((aFieldMask & CLbtTriggerEntry::EAttributeStartUpCommandLine) == CLbtTriggerEntry::EAttributeStartUpCommandLine)    

   713         {

   714         const CLbtStartupTrigger* trigger=static_cast<const CLbtStartupTrigger*>

   715     							(&aTrigger);

   716     	TPtrC commandLinePtr=trigger->CommandLine();

   717     	if(commandLinePtr.Length()==0)

   718     		{

   719     		User::Leave(KErrArgument);

   720         	}

   721         }

   722            

   723 	TIpcArgs args;

   724 	CBufFlat* buffer = CBufFlat::NewL(512);	

   725 	CleanupStack::PushL(buffer);

   726 	RBufWriteStream writeStream;

   727 	writeStream.Open(*buffer);

   728 	CleanupClosePushL(writeStream);

   729 	writeStream << aTrigger;

   730 	writeStream.CommitL();

   731 	CleanupStack::PopAndDestroy(&writeStream);

   732 	TPtr8 ptr1 = buffer->Ptr(0);

   733 

   734 	CleanupStack::Pop(buffer);

   735 	

   736 	TLbtTriggerUpdationInfo triggerUpdationInfo;

   737 	triggerUpdationInfo.iFireOnUpdate = aFireOnUpdate;

   738 	triggerUpdationInfo.iTriggerType = aTrigger.Type();	

   739 	

   740 	TPckg<TLbtTriggerUpdationInfo> pckg(triggerUpdationInfo);

   741 	args.Set( KParamTriggerEntry,&ptr1 );

   742 	args.Set( KParamMask, aFieldMask);

   743 	args.Set( KParamTriggerUpdationInfo,&pckg);

   744 	User::LeaveIfError(SendReceive(ELbtUpdateTrigger, args));

   745 

   746 	delete buffer;

   747     }

   748 

   749 

   750 // ---------------------------------------------------------

   751 // RLbt::UpdateTrigger

   752 //

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

   754 // ---------------------------------------------------------

   755 //

   756 EXPORT_C void RLbt::UpdateTrigger( 

   757             const CLbtTriggerEntry& aTrigger,

   758             TLbtTriggerAttributeFieldsMask aFieldMask,

   759             TLbtFireOnUpdate aFireOnUpdate,

   760             TRequestStatus& aStatus )

   761     {

   762     TRAPD( error,UpdateTriggerL( aTrigger,aFieldMask,aFireOnUpdate,aStatus ));

   763     if( KErrNone != error )

   764         {

   765         TRequestStatus* status=&aStatus;

   766         User::RequestComplete( status,error );

   767         }

   768     }

   769 

   770 // ---------------------------------------------------------

   771 // RLbt::UpdateTriggerL

   772 //

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

   774 // ---------------------------------------------------------

   775 //

   776 void RLbt::UpdateTriggerL( 

   777             const CLbtTriggerEntry& aTrigger,

   778             TLbtTriggerAttributeFieldsMask aFieldMask,

   779             TLbtFireOnUpdate aFireOnUpdate,

   780             TRequestStatus& aStatus )

   781     {

   782     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   783 

   784     if(((aFieldMask & CLbtTriggerEntry::EAttributeId) == CLbtTriggerEntry::EAttributeId)||((aFieldMask & CLbtTriggerEntry::EAttributeManagerUi) == CLbtTriggerEntry::EAttributeManagerUi)||((aFieldMask & CLbtTriggerEntry::EAttributeRequestor) == CLbtTriggerEntry::EAttributeRequestor))

   785         {

   786         User::Leave(KErrAccessDenied);

   787         }

   788 

   789 

   790     if(((aFieldMask & CLbtTriggerEntry::EAttributeCondition) == CLbtTriggerEntry::EAttributeCondition))

   791         {

   792         if(aTrigger.GetCondition()==NULL)

   793             {

   794             User::Leave(KErrArgument);

   795             }

   796             

   797         const CLbtTriggerConditionArea* area = static_cast< const CLbtTriggerConditionArea*> (aTrigger.GetCondition());    

   798         if(area->TriggerArea() == NULL)

   799             {

   800             User::Leave(KErrArgument);

   801             }

   802         }

   803     

   804     if(((aFieldMask & CLbtTriggerEntry::EAttributeName) == CLbtTriggerEntry::EAttributeName))

   805         {

   806         if(aTrigger.Name()==KNullDesC || (aTrigger.Name()).Length()>KLbtMaxNameLength)

   807             {

   808             User::Leave(KErrArgument);

   809             }

   810         } 

   811     

   812     if((aFieldMask & CLbtTriggerEntry::EAttributeStartUpProcessId) == CLbtTriggerEntry::EAttributeStartUpProcessId)    

   813         {

   814         User::Leave(KErrAccessDenied);

   815         }

   816            

   817     if((aFieldMask & CLbtTriggerEntry::EAttributeStartUpCommandLine) == CLbtTriggerEntry::EAttributeStartUpCommandLine)    

   818         {

   819         const CLbtStartupTrigger* trigger=static_cast<const CLbtStartupTrigger*>

   820                                 (&aTrigger);

   821         TPtrC commandLinePtr=trigger->CommandLine();

   822         if(commandLinePtr.Length()==0)

   823             {

   824             User::Leave(KErrArgument);

   825             }

   826         }

   827            

   828     TIpcArgs args;

   829     CBufFlat* buffer = CBufFlat::NewL(512); 

   830     CleanupStack::PushL(buffer);

   831     RBufWriteStream writeStream;

   832     writeStream.Open(*buffer);

   833     CleanupClosePushL(writeStream);

   834     writeStream << aTrigger;

   835     writeStream.CommitL();

   836     CleanupStack::PopAndDestroy(&writeStream);

   837     TPtr8 ptr = buffer->Ptr(0);

   838 

   839     iPtrHolder->Ptr(0).Set(ptr);

   840         

   841     iClientRequester->SetStatus(aStatus);

   842     iClientRequester->SetBuffer(buffer);

   843     

   844     CleanupStack::Pop(buffer);

   845     

   846     iTriggerUpdationInfo->iFireOnUpdate = aFireOnUpdate;

   847     iTriggerUpdationInfo->iTriggerType = aTrigger.Type();

   848     iPtrHolder->Ptr(1).Set(reinterpret_cast<TUint8*>(iTriggerUpdationInfo),

   849                            sizeof(TLbtTriggerUpdationInfo),sizeof(TLbtTriggerUpdationInfo));    

   850     args.Set( KParamTriggerEntry,&iPtrHolder->Ptr(0) );

   851     args.Set( KParamMask, aFieldMask);

   852     args.Set( KParamTriggerUpdationInfo,&iPtrHolder->Ptr(1));

   853     SendReceive(ELbtUpdateTrigger, args,iClientRequester->iStatus);

   854     iClientRequester->Start();

   855     }

   856 

   857 // ---------------------------------------------------------

   858 // RLbt::CancelUpdateTrigger

   859 //

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

   861 // ---------------------------------------------------------

   862 //

   863 EXPORT_C void RLbt::CancelUpdateTrigger()

   864     {

   865     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   866         

   867     TInt error = SendReceive(ELbtCancelUpdateTrigger);    

   868     if( error == KErrNone )

   869         {

   870         iClientRequester->Cancel();

   871         }

   872     }

   873 

   874 // ---------------------------------------------------------

   875 // RLbt::SetTriggerStateL

   876 //

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

   878 // ---------------------------------------------------------

   879 //

   880 EXPORT_C void RLbt::SetTriggerStateL( 

   881             TLbtTriggerId aId, 

   882             CLbtTriggerEntry::TLbtTriggerState aState,

   883             TLbtFireOnUpdate aFireOnUpdate )  

   884     {

   885     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   886 

   887 	TIpcArgs args;

   888 	

   889 	TPckg<TLbtTriggerId> triggerId(aId);

   890 	TPckg<CLbtTriggerEntry::TLbtTriggerState> triggerState(aState);

   891 	TPckg<TLbtFireOnUpdate> fireOnUpdate(aFireOnUpdate);

   892 	

   893 	args.Set(0,&triggerId);

   894 	args.Set(1,&triggerState);

   895 	args.Set(2,&fireOnUpdate);

   896 	User::LeaveIfError(SendReceive(ELbtSetTriggerState, args));

   897     }

   898 

   899 // ---------------------------------------------------------

   900 // RLbt::SetTriggersStateL

   901 //

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

   903 // ---------------------------------------------------------

   904 //

   905 EXPORT_C void RLbt::SetTriggersStateL( CLbtTriggerEntry::TLbtTriggerState aState,

   906                                        TLbtFireOnUpdate aFireOnUpdate,CLbtTriggerFilterBase* aFilter )

   907     {

   908     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   909 

   910 	TIpcArgs args;

   911 	CBufFlat* buffer = CBufFlat::NewL(512);	

   912 	CleanupStack::PushL(buffer);

   913 	RBufWriteStream writeStream;

   914 	writeStream.Open(*buffer);

   915 	CleanupClosePushL(writeStream);

   916 	CLbtTriggerFilterBase::TFilterType type;

   917 	if(aFilter == NULL)

   918 	    {

   919 	    CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

   920 	    CleanupStack::PushL(filter);

   921 		filter->AddTriggerStateL(CLbtTriggerEntry::EStateEnabled);

   922         filter->AddTriggerStateL(CLbtTriggerEntry::EStateDisabled);

   923         writeStream<< *filter;

   924         type = filter->Type();

   925         CleanupStack::PopAndDestroy(filter);

   926 	    }

   927 	else

   928         {

   929         if( aFilter->Type() == CLbtTriggerFilterBase::EFilterByArea )

   930             {

   931             CLbtTriggerFilterByArea* areaFilter = static_cast<CLbtTriggerFilterByArea*> ( aFilter );

   932             ValidateGeoAreaInformationL( areaFilter->Area() );      

   933             }

   934         type = aFilter->Type();

   935         writeStream << *aFilter;

   936         }	    

   937 	writeStream.CommitL();

   938 	CleanupStack::PopAndDestroy(&writeStream);

   939 	TPtr8 ptr = buffer->Ptr(0);

   940    

   941 	

   942 	CleanupStack::Pop(buffer);

   943 	

   944 	TLbtTriggerStateInfo triggerStateInfo;

   945 	triggerStateInfo.iFireOnUpdate = aFireOnUpdate;

   946 	triggerStateInfo.iState = aState;

   947 	

   948 	TPckg<TLbtTriggerStateInfo> pckg(triggerStateInfo);	

   949 	args.Set(KParamFilterType, type);

   950 	args.Set(KParamFilter,&ptr);

   951 	args.Set(KParamTriggerStateInfo,&pckg);

   952 	

   953 	User::LeaveIfError(SendReceive(ELbtSetTriggersState, args));

   954 	delete buffer;

   955     }

   956 

   957 // ---------------------------------------------------------

   958 // RLbt::SetTriggersState

   959 //

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

   961 // ---------------------------------------------------------

   962 //

   963 EXPORT_C void RLbt::SetTriggersState( 

   964             TRequestStatus& aStatus,

   965             CLbtTriggerEntry::TLbtTriggerState aState,

   966             TLbtFireOnUpdate aFireOnUpdate,    

   967             CLbtTriggerFilterBase* aFilter)

   968 

   969     {

   970     TRAPD( error,SetTriggersStateL( aState,aFilter,aFireOnUpdate,aStatus ) );

   971     if( KErrNone != error )

   972     	{

   973     	TRequestStatus* status=&aStatus;

   974     	User::RequestComplete( status,error );

   975     	}

   976     }

   977 // ---------------------------------------------------------

   978 // RLbt::SetTriggersStateL

   979 //

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

   981 // ---------------------------------------------------------

   982 //

   983 void RLbt::SetTriggersStateL( 

   984             CLbtTriggerEntry::TLbtTriggerState aState,

   985             CLbtTriggerFilterBase* aFilter,

   986             TLbtFireOnUpdate aFireOnUpdate,

   987             TRequestStatus& aStatus )

   988             

   989     {

   990     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

   991     aStatus = KRequestPending;

   992     

   993 	if(iClientRequester->IsActive())

   994 		User::Panic(KLbtClientPanicCategory, ELbtDuplicateRequest);

   995 	TIpcArgs args;

   996 

   997     iState = aState;

   998 	

   999 	CBufFlat* buffer=NULL;

  1000 	RBufWriteStream writeStream;

  1001 

  1002     CLbtTriggerFilterBase::TFilterType type;

  1003     buffer = CBufFlat::NewL(512);

  1004     CleanupStack::PushL(buffer);

  1005     writeStream.Open(*buffer);

  1006     CleanupClosePushL(writeStream);

  1007     if(aFilter == NULL)

  1008 	    {

  1009 	    CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

  1010 	    CleanupStack::PushL(filter);

  1011 		filter->AddTriggerStateL(CLbtTriggerEntry::EStateEnabled);

  1012         filter->AddTriggerStateL(CLbtTriggerEntry::EStateDisabled);

  1013         writeStream<< *filter;

  1014         type = filter->Type();

  1015         CleanupStack::PopAndDestroy(filter);

  1016 	    }

  1017 	    

  1018     else

  1019 	    {

  1020 	    if( aFilter->Type() == CLbtTriggerFilterBase::EFilterByArea )

  1021             {

  1022             CLbtTriggerFilterByArea* areaFilter = static_cast<CLbtTriggerFilterByArea*> ( aFilter );

  1023             ValidateGeoAreaInformationL( areaFilter->Area() );

  1024             }

  1025 	    writeStream << *aFilter;

  1026 	    type=aFilter->Type();

  1027 	    }

  1028 	writeStream.CommitL();

  1029 	 

  1030 	CleanupStack::PopAndDestroy(&writeStream);

  1031 	TPtr8 ptr = buffer->Ptr(0);

  1032 

  1033 	iPtrHolder->Ptr(0).Set(ptr);

  1034 		

  1035 	iClientRequester->SetStatus(aStatus);

  1036 	iClientRequester->SetBuffer(buffer);

  1037 	CleanupStack::Pop(buffer);

  1038 	

  1039 	iTriggerStateInfo->iFireOnUpdate = aFireOnUpdate;

  1040 	iTriggerStateInfo->iState = aState;

  1041     

  1042     iPtrHolder->Ptr(1).Set(

  1043     reinterpret_cast<TUint8*>(iTriggerStateInfo),

  1044     sizeof(TLbtTriggerStateInfo),sizeof(TLbtTriggerStateInfo));

  1045 	

  1046 		

  1047 	args.Set(KParamFilterType, type);

  1048 	args.Set(KParamFilter,&iPtrHolder->Ptr(0));

  1049 	args.Set(KParamTriggerStateInfo,&iPtrHolder->Ptr(1));

  1050 	

  1051 	SendReceive(ELbtSetTriggersState, args,iClientRequester->iStatus);

  1052 	iClientRequester->Start();

  1053 	}

  1054 

  1055 // ---------------------------------------------------------

  1056 // RLbt::CancelSetTriggersState

  1057 //

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

  1059 // ---------------------------------------------------------

  1060 //

  1061 EXPORT_C void RLbt::CancelSetTriggersState()

  1062     {

  1063 	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

  1064 	

  1065 	TInt error = SendReceive(ELbtCancelSetTriggersState);	

  1066     if( error == KErrNone )

  1067         {

  1068         iClientRequester->Cancel();

  1069         }	

  1070     }

  1071 

  1072 // ---------------------------------------------------------

  1073 // RLbt::ListTriggerIdsL

  1074 //

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

  1076 // ---------------------------------------------------------

  1077 //

  1078 EXPORT_C void RLbt::ListTriggerIdsL( RArray < TLbtTriggerId >& aTriggerIdList,CLbtListTriggerOptions* aListOptions  )

  1079     {

  1080     __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

  1081 

  1082 		

  1083 	TIpcArgs args;

  1084 	TInt numOfTriggers;

  1085 	iPtrHolder->Ptr(0).Set(

  1086 	reinterpret_cast<TUint8*>(&numOfTriggers),

  1087 	sizeof(numOfTriggers),sizeof(numOfTriggers));

  1088 	args.Set(KTriggersSize,&iPtrHolder->Ptr(0));

  1089 

  1090 	CBufFlat* buf = CBufFlat::NewL(512);	

  1091 	CleanupStack::PushL(buf);

  1092 	RBufWriteStream writeStream;

  1093 	writeStream.Open(*buf);

  1094 	CleanupClosePushL(writeStream);

  1095     

  1096     if(aListOptions)

  1097         {

  1098         CLbtTriggerFilterBase* filter = aListOptions->Filter();

  1099         if( filter )

  1100             {

  1101             if( filter->Type() == CLbtTriggerFilterBase::EFilterByArea )

  1102                 {

  1103                 CLbtTriggerFilterByArea* areaFilter = static_cast<CLbtTriggerFilterByArea*> ( filter );

  1104                 ValidateGeoAreaInformationL( areaFilter->Area() );

  1105                 }

  1106             }

  1107         writeStream << *aListOptions;

  1108         }

  1109         

  1110 	if(!aListOptions)

  1111 		{

  1112 	    CLbtListTriggerOptions* listOptions = CLbtListTriggerOptions::NewL();

  1113 		CleanupStack::PushL(listOptions);

  1114 		CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

  1115 		CleanupStack::PushL(filter);

  1116 		filter->AddTriggerStateL(CLbtTriggerEntry::EStateEnabled);

  1117         filter->AddTriggerStateL(CLbtTriggerEntry::EStateDisabled);

  1118         listOptions->SetFilter(filter);        

  1119 		writeStream << *listOptions;

  1120 		CleanupStack::PopAndDestroy(filter);

  1121 		CleanupStack::PopAndDestroy(listOptions);

  1122 		}

  1123 		

  1124 	writeStream.CommitL();

  1125 	CleanupStack::PopAndDestroy(&writeStream);

  1126 	TPtr8 ptr = buf->Ptr(0);

  1127 	args.Set(KParamFilter, &ptr);

  1128 	TInt error = SendReceive(ELbtGetListTriggerIdsSize,args);

  1129 	CleanupStack::PopAndDestroy(); //buf

  1130 	

  1131 	if( error != KErrNotFound )

  1132 	    {

  1133 	    User::LeaveIfError( error );

  1134 	    }

  1135