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:        

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 // INCLUDE FILES

    26 #include <aknnotewrappers.h>

    27 #include <AknNotifyStd.h>

    28 #include <ConeResLoader.h>

    29 #include <StringLoader.h>

    30 

    31 #ifndef RD_SEN_COMPILE_SIS_PACKAGE_FILES

    32     #include <SenNotifierPluginDlgImpl.rsg>

    33 #else

    34     #include <WsNotifierPluginDlgImpl.rsg>

    35 #endif

    36 

    37 // This may be angle bracketed later..

    38 #include "logger.h"

    39 #include "sennotplugindlg.h" // client api

    40 #include "sennotplugindlgimpl.h"

    41 

    42 #include <implementationproxy.h>

    43 

    44 

    45 #ifdef EKA2 // 3.0

    46   #ifndef RD_SEN_COMPILE_SIS_PACKAGE_FILES

    47     _LIT(KResourceFilePath, "\\private\\10003a4a\\SenNotifierPluginDlgImpl.RSC");

    48   #else

    49     _LIT(KResourceFilePath, "\\private\\10003a4a\\WsNotifierPluginDlgImpl.RSC");

    50   #endif

    51 #else // not EKA2 (2.0, 2.1, 2.6, 2.8)

    52   #ifndef RD_SEN_COMPILE_SIS_PACKAGE_FILES

    53     _LIT(KResourceFilePath, "\\system\\notifiers\\SenNotifierPluginDlgImpl.RSC");

    54   #else

    55     _LIT(KResourceFilePath, "\\system\\notifiers\\WsNotifierPluginDlgImpl.RSC");

    56   #endif

    57 #endif // EKA2

    58 

    59 #ifdef EKA2

    60 void CreateNotifierL(CArrayPtr<MEikSrvNotifierBase2>* aNotifiers)

    61     {

    62     MEikSrvNotifierBase2* notifier;

    63     notifier = CSenNotPluginDlgImpl::NewL();

    64     CleanupStack::PushL(notifier);

    65     aNotifiers->AppendL(notifier);

    66     CleanupStack::Pop(notifier);

    67     }

    68 #else

    69 void CreateNotifierL(CArrayPtr<MEikSrvNotifierBase>* aNotifiers)

    70     {

    71     MEikSrvNotifierBase* notifier;

    72     notifier = CSenNotPluginDlgImpl::NewL();

    73     CleanupStack::PushL(notifier);

    74     aNotifiers->AppendL(notifier);

    75     CleanupStack::Pop(notifier);

    76     }

    77 #endif

    78 

    79 #ifdef EKA2

    80 EXPORT_C CArrayPtr<MEikSrvNotifierBase2>* NotifierArray()

    81     {

    82     DOLOG(_L("\n\n\n\n"));

    83     DOLOG(_L("[ Creating notifier array ]"));

    84     CArrayPtrFlat<MEikSrvNotifierBase2>* notifiers

    85         = new CArrayPtrFlat<MEikSrvNotifierBase2>(1);

    86     if (notifiers)

    87         {

    88         TRAPD(err, CreateNotifierL(notifiers));

    89         if(err)

    90             {

    91             notifiers->ResetAndDestroy();

    92             delete notifiers;

    93             notifiers = NULL;

    94             DOLOG(_L("[ Creating notifier array: Error. Returning NULL ]"));

    95             }

    96         }

    97     DOLOG(_L("[ Creating notifier array: Done ]"));

    98     return(notifiers);

    99     }

   100 #else

   101 EXPORT_C CArrayPtr<MEikSrvNotifierBase>* NotifierArray()

   102     {

   103     DOLOG(_L("\n\n\n\n"));

   104     DOLOG(_L("[ Creating notifier array ]"));

   105     CArrayPtrFlat<MEikSrvNotifierBase>* notifiers

   106         = new CArrayPtrFlat<MEikSrvNotifierBase>(1);

   107     if (notifiers)

   108         {

   109         TRAPD(err, CreateNotifierL(notifiers));

   110         if(err)

   111             {

   112             notifiers->ResetAndDestroy();

   113             delete notifiers;

   114             notifiers = NULL;

   115             DOLOG(_L("[ Creating notifier array: Error. Returning NULL ]"));

   116             }

   117         }

   118     DOLOG(_L("[ Creating notifier array: Done ]"));

   119     return(notifiers);

   120     }

   121 #endif

   122 

   123 CSenNotPluginDlgImpl* CSenNotPluginDlgImpl::NewL()

   124     {

   125     DOLOG(_L("[ CSenNotPluginDlgImpl::NewL: Starting ]"));

   126     CSenNotPluginDlgImpl* dlg = new(ELeave)CSenNotPluginDlgImpl();

   127     CleanupStack::PushL(dlg);

   128     dlg->ConstructL();

   129     CleanupStack::Pop(dlg);

   130     DOLOG(_L("[ CSenNotPluginDlgImpl::NewL: Done ]"));

   131     return dlg;

   132     }

   133 

   134 CSenNotPluginDlgImpl::~CSenNotPluginDlgImpl()

   135     {

   136     Cancel();

   137     Cleanup();

   138     }

   139 

   140 CSenNotPluginDlgImpl::CSenNotPluginDlgImpl() : CActive(EPriorityStandard),

   141     iMethod(TSenNotPluginRequest::ENoMethod)

   142     {

   143     CActiveScheduler::Add(this);

   144     }

   145 

   146 void CSenNotPluginDlgImpl::ConstructL()

   147     {

   148     }

   149 

   150 void CSenNotPluginDlgImpl::RunL()

   151     {

   152     if(iMethod == TSenNotPluginRequest::ENoMethod)

   153         return; // Notifier canceled or request signaled by other means

   154 

   155     HandleAsyncRequestL(); // show dialog

   156     Cleanup();

   157     }

   158 

   159 TInt CSenNotPluginDlgImpl::RunError(TInt aError)

   160     {

   161     iMessage.Complete(aError);

   162     Cleanup();

   163     return KErrNone;

   164     }

   165 

   166 void CSenNotPluginDlgImpl::DoCancel()

   167     {

   168     }

   169 

   170 /**

   171  * Called when all resources allocated by notifiers shoudl be freed.

   172  */

   173 void CSenNotPluginDlgImpl::Release()

   174     {

   175     DOLOG(_L("[ CSenNotPluginDlgImpl::Release: Deleting this ]"));

   176     delete this;

   177     }

   178 

   179 /**

   180  * Called when a notifier is first loaded to allow any initial construction that is required.

   181  */

   182 #ifdef EKA2

   183 MEikSrvNotifierBase2::TNotifierInfo CSenNotPluginDlgImpl::RegisterL()

   184 #else

   185 MEikSrvNotifierBase::TNotifierInfo CSenNotPluginDlgImpl::RegisterL()

   186 #endif

   187     {

   188     DOLOG(_L("[ CSenNotPluginDlgImpl::RegisterL ]"));

   189     iInfo.iUid = KSenNotifierPluginUID;

   190     //iInfo.iChannel = EAknNotifierChannelConfirmationQuery; //KNotifierOutputChannelScreen;

   191     iInfo.iChannel = TUid::Uid(7641863);

   192     iInfo.iPriority = ENotifierPriorityLow; //ENotifierPriorityVHigh;

   193     DOLOG(_L("[ CSenNotPluginDlgImpl::RegisterL: Done ]"));

   194     return iInfo;

   195     }

   196 

   197 /**

   198  * Return the priority a notifier takes and the channels it acts on.  The return value may be varied

   199  * at run-time.

   200  */

   201 #ifdef EKA2

   202 MEikSrvNotifierBase2::TNotifierInfo CSenNotPluginDlgImpl::Info() const

   203 #else

   204 MEikSrvNotifierBase::TNotifierInfo CSenNotPluginDlgImpl::Info() const

   205 #endif

   206     {

   207     DOLOG(_L("[ CSenNotPluginDlgImpl::Info ]"));

   208     return iInfo;

   209     }

   210 

   211 /**

   212  * Start the notifier with data aBuffer and return an initial response.

   213  */

   214 TPtrC8 CSenNotPluginDlgImpl::StartL(const TDesC8& /*aBuffer*/)

   215     {

   216     DOLOG(_L("[ CSenNotPluginDlgImpl::StartL(aBuffer): Not implemented ]"));

   217     //Create and launch confirmation dialog using static function.

   218     //The function returns True when the OK button is pressed.

   219     DOLOG(_L("[ CSenNotPluginDlgImpl::StartL(aBuffer): Done ]"));

   220     return TPtrC8(NULL, 0);

   221     }

   222 

   223 void CSenNotPluginDlgImpl::HandleAsyncRequestL()

   224     {

   225     DOLOG(_L("[ CSenNotPluginDlgImpl::HandleAsyncRequestL: Starting ]"));

   226 

   227     // Load resource file

   228     CEikonEnv* eikEnv = CEikonEnv::Static();

   229     if(!eikEnv)

   230         {

   231         DOLOG(_L("[ CSenNotPluginDlgImpl::HandleAsyncRequestL: EikEnv is NULL ]"));

   232         }

   233     else

   234         {

   235         DOLOG(_L("[ CSenNotPluginDlgImpl::HandleAsyncRequestL: EikEnv is valid ]"));

   236         }

   237 

   238     // Figure out the resource file drive trusting that 

   239     // it must be the same drive from which the DLL was loaded.

   240 

   241     TParse parse;

   242     TFileName tempFileName;

   243 

   244     Dll::FileName(tempFileName);

   245     parse.SetNoWild(tempFileName, NULL, NULL);

   246     // We need to set the default path to be used for future file access, because

   247     // it is always initialised to c: and the voice control files may be stored

   248     // on the d: drive.

   249 

   250     TFileName filename;

   251     filename.Append(parse.Drive());

   252     filename.Append(KResourceFilePath);

   253 

   254 //    TFileName filename(KResourceFile);

   255 

   256 

   257     DOLOG(filename);

   258 

   259     RConeResourceLoader resLoader(*eikEnv);

   260     if(resLoader.Open(filename) != KErrNone)

   261         {

   262         DOLOG(_L("[ CSenNotPluginDlgImpl::HandleAsyncRequestL: Failed to open resource file ]"));

   263         }

   264     else

   265         {

   266         DOLOG(_L("[ CSenNotPluginDlgImpl::HandleAsyncRequestL: Resource file opened OK. ]"));

   267         }

   268 

   269     CleanupClosePushL(resLoader);

   270     

   271     TInt result = KErrGeneral;

   272     switch(iMethod)

   273         {

   274         case TSenNotPluginRequest::EAuthenticationDlg:

   275             result = ShowAuthenticationDialogL((TAuthenticationDlgRequest*)&((*iRequest)()),

   276                 (TAuthenticationDlgResponse*)&((*iResponse)()));

   277             break;

   278         case TSenNotPluginRequest::EAllowRegisterDlg:

   279             result = ShowAllowRegisterDialogL((TAllowRegisterDlgRequest*)&((*iRequest)()),

   280                 (TAllowRegisterDlgResponse*)&((*iResponse)()));

   281             break;

   282         case TSenNotPluginRequest::EAllowUnRegisterDlg:

   283             result = ShowAllowUnRegisterDialogL((TAllowUnRegisterDlgRequest*)&((*iRequest)()),

   284                 (TAllowUnRegisterDlgResponse*)&((*iResponse)()));

   285             break;

   286         case TSenNotPluginRequest::EAskSaveDlg:

   287             result = ShowAskSaveDialogL((TAskSaveDlgRequest*)&((*iRequest)()),

   288                (TAskSaveDlgResponse*)&((*iResponse)()));

   289             break;

   290         default:

   291             break;

   292         }

   293         

   294     if(iCancelled)

   295         {

   296         DOLOG(_L("[ CSenNotPluginDlgImpl::HandleAsyncRequestL: Operation had been cancelled. Completing with KErrCancel ]"));

   297         iMessage.Complete(KErrCancel);

   298         }

   299     else

   300         {

   301         if(result == KErrNone)

   302 #ifdef EKA2

   303             iMessage.WriteL(iReplySlot, *iResponse);

   304 #else

   305             iMessage.WriteL(iReplyPtr, *iResponse);

   306 #endif            

   307         iMessage.Complete(result);

   308         }

   309 

   310     CleanupStack::PopAndDestroy(); // resLoader

   311     DOLOG(_L("[ CSenNotPluginDlgImpl::HandleAsyncRequestL: Done ]"));

   312 

   313     }

   314 

   315 /**

   316  * Start the notifier with data aBuffer.  aMessage should be completed when the notifier is deactivated.

   317  * May be called multiple times if more than one client starts the notifier.  The notifier is immediately

   318  * responsible for completing aMessage.

   319  */

   320 #ifdef EKA2

   321 void CSenNotPluginDlgImpl::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

   322 #else

   323 void CSenNotPluginDlgImpl::StartL(const TDesC8& aBuffer, const TAny* aReturnVal, RMessage aMessage)

   324 #endif

   325     {

   326     DOLOG(_L("[ CSenNotPluginDlgImpl::StartL(aBuffer, aReturnVal, aMessage): Starting ]"));

   327 

   328     if(iMethod != TSenNotPluginRequest::ENoMethod)

   329         {

   330         DOLOG(_L("[ CSenNotPluginDlgImpl::StartL(aBuffer, aReturnVal, aMessage): Busy. Returning KErrInUse ]"));

   331         aMessage.Complete(KErrInUse);

   332         return;

   333         }

   334 

   335     Cleanup();

   336 

   337     iRequest = new(ELeave)TPckgBuf<TSenNotPluginRequest>();

   338     iRequest->Copy(aBuffer.Ptr(), sizeof(TSenNotPluginRequest));

   339     iResponse = new(ELeave)TPckgBuf<TSenNotPluginResponse>();

   340 

   341     iMethod = (*iRequest)().Method();

   342     iMessage = aMessage;    

   343 #ifdef EKA2

   344     iReplySlot = aReplySlot;

   345 #else

   346     iReplyPtr = aReturnVal;

   347 #endif

   348 

   349     iStatus = KRequestPending;

   350     TRequestStatus* status = &iStatus;

   351     SetActive();

   352     User::RequestComplete(status, KErrNone);

   353 

   354     DOLOG(_L("[ CSenNotPluginDlgImpl::StartL(aBuffer, aReturnVal, aMessage): Done ]"));

   355     }

   356 

   357 

   358 TInt CSenNotPluginDlgImpl::ShowAuthenticationDialogL(TAuthenticationDlgRequest* aRequest,

   359     TAuthenticationDlgResponse* aResponse)

   360     {

   361     // Note: default password is currently unsupported!

   362     DOLOG(_L("[ CSenNotPluginDlgImpl::ShowAuthenticationDialogL: Starting ]"));

   363 

   364     TBuf<KSenMaxUsernameLength> username(aRequest->Username());

   365     TBuf<KSenMaxPasswordLength> password; // Empty

   366 

   367     DOLOG(_L("[ CSenNotPluginDlgImpl::ShowAuthenticationDialogL: Creating dialog ]"));

   368     CAknMultiLineDataQueryDialog* dlg = CAknMultiLineDataQueryDialog::NewL(username, password);

   369     iDialog = dlg;

   370     TRAPD(err,

   371         DOLOG(_L("[ CSenNotPluginDlgImpl::ShowAuthenticationDialogL: Showing dialog ]"));

   372         TBool okButtonSelected = iDialog->ExecuteLD(R_CUSTOM_USERNAMEPASSWD_DIALOG);

   373         if(okButtonSelected)

   374             {

   375             DOLOG(_L("[ CSenNotPluginDlgImpl::ShowAuthenticationDialogL: Ok button was selected ]"));

   376             aResponse->SetData(username, password, okButtonSelected);

   377             }

   378         else

   379             {

   380             DOLOG(_L("[ CSenNotPluginDlgImpl::ShowAuthenticationDialogL: Cancel button was selected ]"));

   381             aResponse->SetData(KNullDesC, KNullDesC, okButtonSelected);

   382             }

   383         )

   384     dlg = NULL;

   385 

   386 #ifdef __CUSTOM_LOG_ENABLED__

   387     TBuf<128> errorBuf(_L("CSenNotPluginDlgImpl::ShowAuthenticationDialogL: Done with error code = "));

   388     errorBuf.AppendNum(err);

   389     DOLOG(errorBuf);

   390 #endif

   391 

   392     return err;

   393     }

   394 

   395 TInt CSenNotPluginDlgImpl::ShowAllowRegisterDialogL(TAllowRegisterDlgRequest* /*aRequest*/,

   396     TAllowRegisterDlgResponse* aResponse)

   397     {

   398     HBufC* prompt = StringLoader::LoadL(R_SENNOTDLG_ALLOW_REGISTER_QUERY);

   399     CleanupStack::PushL(prompt);

   400     CAknQueryDialog* dlg = CAknQueryDialog::NewL();

   401     CleanupStack::PushL( dlg ); 

   402     dlg->SetPromptL(*prompt);

   403     CleanupStack::Pop( dlg );  

   404     CleanupStack::PopAndDestroy(prompt);

   405     iDialog = dlg;

   406     TRAPD(err,

   407         if(dlg->ExecuteLD(R_COMMON_YES_NO_QUERY))

   408             {

   409             aResponse->SetOkButton(ETrue);

   410             }

   411         else

   412             {

   413             aResponse->SetOkButton(EFalse);

   414             }

   415         )

   416     iDialog = NULL;

   417 

   418     return err;

   419     }

   420 

   421 TInt CSenNotPluginDlgImpl::ShowAllowUnRegisterDialogL(TAllowUnRegisterDlgRequest* /*aRequest*/,

   422     TAllowUnRegisterDlgResponse* aResponse)

   423     {

   424     HBufC* prompt = StringLoader::LoadL(R_SENNOTDLG_ALLOW_UNREGISTER_QUERY);

   425     CleanupStack::PushL(prompt);

   426     CAknQueryDialog* dlg = CAknQueryDialog::NewL();

   427     CleanupStack::PushL( dlg ); 

   428     dlg->SetPromptL(*prompt);

   429     CleanupStack::Pop( dlg ); 

   430     CleanupStack::PopAndDestroy(prompt);

   431     iDialog = dlg;

   432     TRAPD(err,

   433         if(dlg->ExecuteLD(R_COMMON_YES_NO_QUERY))

   434             {

   435             aResponse->SetOkButton(ETrue);

   436             }

   437         else

   438             {

   439             aResponse->SetOkButton(EFalse);

   440             }

   441         )

   442     iDialog = NULL;

   443     return err;

   444     }

   445     

   446 TInt CSenNotPluginDlgImpl::ShowAskSaveDialogL(TAskSaveDlgRequest* /*aRequest*/,

   447     TAskSaveDlgResponse* aResponse)

   448     {

   449     HBufC* prompt = StringLoader::LoadL(R_SENNOTDLG_ASK_SAVE_QUERY);

   450     CleanupStack::PushL(prompt);

   451     CAknQueryDialog* dlg = CAknQueryDialog::NewL();

   452     CleanupStack::PushL( dlg ); 

   453     dlg->SetPromptL(*prompt);

   454     CleanupStack::Pop( dlg ); 

   455     CleanupStack::PopAndDestroy(prompt);

   456     iDialog = dlg;

   457     TRAPD(err,

   458         if(dlg->ExecuteLD(R_COMMON_YES_NO_QUERY))

   459             {

   460             aResponse->SetOkButton(ETrue);

   461             }

   462         else

   463             {

   464             aResponse->SetOkButton(EFalse);

   465             }

   466         )

   467     iDialog = NULL;

   468     return err;

   469     }

   470 

   471 

   472 void CSenNotPluginDlgImpl::Cleanup()

   473     {

   474     iMethod = TSenNotPluginRequest::ENoMethod;

   475     iCancelled = EFalse;

   476 #ifdef EKA2    

   477     iReplySlot = NULL;

   478 #else

   479     iReplyPtr = NULL;

   480 #endif    

   481     delete iRequest;

   482     iRequest = NULL;

   483     delete iResponse;

   484     iResponse = NULL;

   485     }

   486 

   487 

   488 /**

   489  * The notifier has been deactivated so resources can be freed and outstanding messages completed.

   490  */

   491 void CSenNotPluginDlgImpl::Cancel()

   492     {

   493     DOLOG(_L("[ CSenNotPluginDlgImpl::Cancel: Starting ]"));

   494 

   495     if(iMethod == TSenNotPluginRequest::ENoMethod)

   496         {

   497         DOLOG(_L("[ CSenNotPluginDlgImpl::Cancel: No outstanding request. Freeing resources ]"));

   498         Cleanup();

   499         }

   500     else

   501         {

   502         if(iDialog)

   503             {

   504             DOLOG(_L("[ CSenNotPluginDlgImpl::Cancel: dialog is being displayed. Cancelling it ]"));

   505 /*            if(iMethod == TSenNotPluginRequest::EAuthenticationDlg)

   506                 {

   507                 ((CUsernamePasswdDialog*)iDialog)->CancelDialogL(); // Will delete dialog

   508                 iDialog = NULL; //

   509                 }

   510             else*/

   511                 {

   512                 TKeyEvent keyEvent;

   513                 keyEvent.iCode = EKeyEscape;

   514                 keyEvent.iScanCode = EStdKeyEscape;

   515                 keyEvent.iModifiers = EModifierAutorepeatable;

   516                 keyEvent.iRepeats = 50;

   517                 TInt leaveCode(KErrNone);

   518                 TRAP(leaveCode, iDialog->OfferKeyEventL(keyEvent, EEventKey));

   519                 if (leaveCode != KErrNone) iCancelled = EFalse;

   520                 }

   521 

   522             DOLOG(_L("[ CSenNotPluginDlgImpl::Cancel: dialog cancel initiated ]"));

   523                 // Note: Execution will continue in RunL, where cleanup must be performed

   524             iCancelled = ETrue;

   525             }

   526         else

   527             {

   528             DOLOG(_L("[ CSenNotPluginDlgImpl::Cancel: Pending request, but not executing it. Freeing resource ]"));

   529             Cleanup(); // This will effectively cancel asynchronous operation

   530             }

   531         }

   532     }

   533 

   534 /**

   535  * Update a currently active notifier with data aBuffer.

   536  */

   537 TPtrC8 CSenNotPluginDlgImpl::UpdateL(const TDesC8& /*aBuffer*/)

   538     {

   539     DOLOG(_L("[ CSenNotPluginDlgImpl::UpdateL ]"));

   540     return TPtrC8(NULL, 0);

   541     }

   542 

   543 #ifdef EKA2

   544 // ----------------------------------------------------------

   545 //

   546 // ECOM 

   547 //

   548 // -----------------------------------------------------------

   549 

   550 const TImplementationProxy ImplementationTable[] =

   551     {

   552 #ifndef RD_SEN_COMPILE_SIS_PACKAGE_FILES

   553     IMPLEMENTATION_PROXY_ENTRY(0x101F9765,NotifierArray)

   554 #else

   555     IMPLEMENTATION_PROXY_ENTRY(0x101F9744,NotifierArray)

   556 #endif    

   557 

   558     };

   559 

   560 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

   561     {

   562     aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy) ;

   563     return ImplementationTable;

   564     }

   565 #endif

   566 

   567 // End of File