appinstall_plat/sifui_api/src/sifui.cpp
changeset 29 26b6f0522fd8
parent 25 98b66e4fb0be
child 37 6e7b00453237
equal deleted inserted replaced
25:98b66e4fb0be 29:26b6f0522fd8
    14 * Description:  Implementation of RSifUiCli class.
    14 * Description:  Implementation of RSifUiCli class.
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 #include "sifui.h"                              // CSifUi
    18 #include "sifui.h"                              // CSifUi
    19 #include "sifuidefs.h"                          // SIF UI device dialog parameters
    19 #include "sifuiprivate.h"                       // CSifUiPrivate
    20 #include <hb/hbcore/hbsymbiandevicedialog.h>    // CHbDeviceDialog
       
    21 #include <hb/hbcore/hbsymbianvariant.h>         // CHbSymbianVariantMap
       
    22 #include <swi/msisuihandlers.h>                 // Swi::CAppInfo
       
    23 #include <apgicnfl.h>                           // CApaMaskedBitmap
       
    24 
    20 
    25 
    21 
    26 // ======== MEMBER FUNCTIONS ========
    22 // ======== MEMBER FUNCTIONS ========
    27 
    23 
    28 // ---------------------------------------------------------------------------
    24 // ---------------------------------------------------------------------------
    52 // CSifUi::~CSifUi()
    48 // CSifUi::~CSifUi()
    53 // ---------------------------------------------------------------------------
    49 // ---------------------------------------------------------------------------
    54 //
    50 //
    55 CSifUi::~CSifUi()
    51 CSifUi::~CSifUi()
    56     {
    52     {
    57     Cancel();
    53 	delete iPrivate;
    58     delete iWait;
       
    59     delete iDeviceDialog;
       
    60     delete iVariantMap;
       
    61     delete iBitmap;
       
    62     }
       
    63 
       
    64 // ---------------------------------------------------------------------------
       
    65 // CSifUi::SetMode()
       
    66 // ---------------------------------------------------------------------------
       
    67 //
       
    68 EXPORT_C void CSifUi::SetMode( TMode aMode )
       
    69     {
       
    70     iMode = aMode;
       
    71     }
       
    72 
       
    73 // ---------------------------------------------------------------------------
       
    74 // CSifUi::Mode()
       
    75 // ---------------------------------------------------------------------------
       
    76 //
       
    77 EXPORT_C CSifUi::TMode CSifUi::Mode()
       
    78     {
       
    79     return iMode;
       
    80     }
    54     }
    81 
    55 
    82 // ---------------------------------------------------------------------------
    56 // ---------------------------------------------------------------------------
    83 // CSifUi::ShowConfirmationL()
    57 // CSifUi::ShowConfirmationL()
    84 // ---------------------------------------------------------------------------
    58 // ---------------------------------------------------------------------------
    85 //
    59 //
    86 EXPORT_C TBool CSifUi::ShowConfirmationL( const Swi::CAppInfo& aAppInfo,
    60 EXPORT_C TBool CSifUi::ShowConfirmationL( const Swi::CAppInfo& aAppInfo,
    87         TInt aAppSize, const CApaMaskedBitmap* aAppIcon,
    61     TInt aAppSize, const CApaMaskedBitmap* aAppIcon )
       
    62 	{
       
    63 	return iPrivate->ShowConfirmationL( aAppInfo, aAppSize, aAppIcon );
       
    64 	}
       
    65 
       
    66 // ---------------------------------------------------------------------------
       
    67 // CSifUi::SetMemorySelectionL()
       
    68 // ---------------------------------------------------------------------------
       
    69 //
       
    70 EXPORT_C void CSifUi::SetMemorySelectionL( const RArray<TInt>& aDriveNumbers )
       
    71 	{
       
    72 	iPrivate->SetMemorySelectionL( aDriveNumbers );
       
    73 	}
       
    74 
       
    75 // ---------------------------------------------------------------------------
       
    76 // CSifUi::SelectedDrive()
       
    77 // ---------------------------------------------------------------------------
       
    78 //
       
    79 EXPORT_C TInt CSifUi::SelectedDrive( TInt& aDriveNumber )
       
    80 	{
       
    81 	return iPrivate->SelectedDrive( aDriveNumber );
       
    82 	}
       
    83 
       
    84 // ---------------------------------------------------------------------------
       
    85 // CSifUi::SetCertificateInfoL()
       
    86 // ---------------------------------------------------------------------------
       
    87 //
       
    88 EXPORT_C void CSifUi::SetCertificateInfoL(
    88         const RPointerArray<Swi::CCertificateInfo>& aCertificates )
    89         const RPointerArray<Swi::CCertificateInfo>& aCertificates )
    89     {
    90 	{
    90     ChangeNoteTypeL( ESifUiConfirmationQuery );
    91 	iPrivate->SetCertificateInfoL( aCertificates );
    91 
    92 	}
    92     AddParamsAppInfoAndSizeL( aAppInfo, aAppSize );
       
    93     if( aAppIcon )
       
    94         {
       
    95         AddParamsIconL( aAppIcon );
       
    96         }
       
    97     if( aCertificates.Count() )
       
    98         {
       
    99         AddParamsCertificatesL( aCertificates );
       
   100         }
       
   101 
       
   102     // TODO: send drive list for drive selection, get selected drive
       
   103     AddParamL( KSifUiMemorySelection, ETrue );
       
   104 
       
   105     DisplayDeviceDialogL();
       
   106     User::LeaveIfError( WaitForResponse() );
       
   107     return( iReturnValue == KErrNone );
       
   108     }
       
   109 
    93 
   110 // ---------------------------------------------------------------------------
    94 // ---------------------------------------------------------------------------
   111 // CSifUi::ShowProgressL()
    95 // CSifUi::ShowProgressL()
   112 // ---------------------------------------------------------------------------
    96 // ---------------------------------------------------------------------------
   113 //
    97 //
   114 EXPORT_C void CSifUi::ShowProgressL( const Swi::CAppInfo& aAppInfo,
    98 EXPORT_C void CSifUi::ShowProgressL( const Swi::CAppInfo& aAppInfo,
   115         TInt aAppSize, TInt aProgressBarFinalValue )
    99         TInt aAppSize, TInt aProgressBarFinalValue )
   116     {
   100     {
   117     ChangeNoteTypeL( ESifUiProgressNote );
   101 	iPrivate->ShowProgressL( aAppInfo, aAppSize, aProgressBarFinalValue );
   118 
       
   119     AddParamsAppInfoAndSizeL( aAppInfo, aAppSize );
       
   120     AddParamL( KSifUiProgressNoteFinalValue, aProgressBarFinalValue );
       
   121 
       
   122     DisplayDeviceDialogL();
       
   123     }
   102     }
   124 
   103 
   125 // ---------------------------------------------------------------------------
   104 // ---------------------------------------------------------------------------
   126 // CSifUi::IncreaseProgressBarValueL()
   105 // CSifUi::IncreaseProgressBarValueL()
   127 // ---------------------------------------------------------------------------
   106 // ---------------------------------------------------------------------------
   128 //
   107 //
   129 EXPORT_C void CSifUi::IncreaseProgressBarValueL( TInt aNewValue )
   108 EXPORT_C void CSifUi::IncreaseProgressBarValueL( TInt aNewValue )
   130     {
   109     {
   131     ChangeNoteTypeL( ESifUiProgressNote );
   110 	iPrivate->IncreaseProgressBarValueL( aNewValue );
   132 
       
   133     AddParamL( KSifUiProgressNoteValue, aNewValue );
       
   134 
       
   135     DisplayDeviceDialogL();
       
   136     }
   111     }
   137 
   112 
   138 // ---------------------------------------------------------------------------
   113 // ---------------------------------------------------------------------------
   139 // CSifUi::ShowCompleteL()
   114 // CSifUi::ShowCompleteL()
   140 // ---------------------------------------------------------------------------
   115 // ---------------------------------------------------------------------------
   141 //
   116 //
   142 EXPORT_C void CSifUi::ShowCompleteL()
   117 EXPORT_C void CSifUi::ShowCompleteL()
   143     {
   118     {
   144     ChangeNoteTypeL( ESifUiCompleteNote );
   119 	iPrivate->ShowCompleteL();
   145     DisplayDeviceDialogL();
       
   146     User::LeaveIfError( WaitForResponse() );
       
   147     }
   120     }
   148 
   121 
   149 // ---------------------------------------------------------------------------
   122 // ---------------------------------------------------------------------------
   150 // CSifUi::ShowFailedL()
   123 // CSifUi::ShowFailedL()
   151 // ---------------------------------------------------------------------------
   124 // ---------------------------------------------------------------------------
   152 //
   125 //
   153 EXPORT_C void CSifUi::ShowFailedL( TInt aErrorCode )
   126 EXPORT_C void CSifUi::ShowFailedL( TInt aErrorCode, const TDesC& aErrorMessage,
       
   127         const TDesC& aErrorDetails )
   154     {
   128     {
   155     ChangeNoteTypeL( ESifUiErrorNote );
   129 	iPrivate->ShowFailedL( aErrorCode, aErrorMessage, aErrorDetails );
   156 
       
   157     AddParamL( KSifUiErrorCode, aErrorCode );
       
   158 
       
   159     DisplayDeviceDialogL();
       
   160     User::LeaveIfError( WaitForResponse() );
       
   161     }
       
   162 
       
   163 // ---------------------------------------------------------------------------
       
   164 // CSifUi::DoCancel()
       
   165 // ---------------------------------------------------------------------------
       
   166 //
       
   167 void CSifUi::DoCancel()
       
   168     {
       
   169     if( iWait && iWait->IsStarted() && iWait->CanStopNow() )
       
   170         {
       
   171         iCompletionCode = KErrCancel;
       
   172         iWait->AsyncStop();
       
   173         }
       
   174     }
       
   175 
       
   176 // ---------------------------------------------------------------------------
       
   177 // CSifUi::RunL()
       
   178 // ---------------------------------------------------------------------------
       
   179 //
       
   180 void CSifUi::RunL()
       
   181     {
       
   182     if( iWait )
       
   183         {
       
   184         iWait->AsyncStop();
       
   185         }
       
   186     }
       
   187 
       
   188 // ---------------------------------------------------------------------------
       
   189 // CSifUi::DataReceived()
       
   190 // ---------------------------------------------------------------------------
       
   191 //
       
   192 void CSifUi::DataReceived( CHbSymbianVariantMap& aData )
       
   193     {
       
   194     const CHbSymbianVariant* acceptedVariant = aData.Get( KSifUiQueryAccepted );
       
   195     if( acceptedVariant )
       
   196         {
       
   197         TBool* acceptedValue = acceptedVariant->Value<TBool>();
       
   198         if( acceptedValue && *acceptedValue )
       
   199             {
       
   200             iReturnValue = KErrNone;
       
   201             }
       
   202         else
       
   203             {
       
   204             iReturnValue = KErrCancel;
       
   205             }
       
   206         ResponseReceived( KErrNone );
       
   207         }
       
   208     }
       
   209 
       
   210 // ---------------------------------------------------------------------------
       
   211 // CSifUi::DeviceDialogClosed()
       
   212 // ---------------------------------------------------------------------------
       
   213 //
       
   214 void CSifUi::DeviceDialogClosed( TInt aCompletionCode )
       
   215     {
       
   216     iIsDisplayingDialog = EFalse;
       
   217     ResponseReceived( aCompletionCode );
       
   218     }
   130     }
   219 
   131 
   220 // ---------------------------------------------------------------------------
   132 // ---------------------------------------------------------------------------
   221 // CSifUi::CSifUi()
   133 // CSifUi::CSifUi()
   222 // ---------------------------------------------------------------------------
   134 // ---------------------------------------------------------------------------
   223 //
   135 //
   224 CSifUi::CSifUi() : CActive( CActive::EPriorityStandard )
   136 CSifUi::CSifUi()
   225     {
   137     {
   226     CActiveScheduler::Add( this );
       
   227     }
   138     }
   228 
   139 
   229 // ---------------------------------------------------------------------------
   140 // ---------------------------------------------------------------------------
   230 // CSifUi::ConstructL()
   141 // CSifUi::ConstructL()
   231 // ---------------------------------------------------------------------------
   142 // ---------------------------------------------------------------------------
   232 //
   143 //
   233 void CSifUi::ConstructL()
   144 void CSifUi::ConstructL()
   234     {
   145     {
   235     iWait = new( ELeave ) CActiveSchedulerWait;
   146 	iPrivate = CSifUiPrivate::NewL();
   236     // iDeviceDialog is allocated later, first call of DisplayDeviceDialogL()
       
   237     }
   147     }
   238 
   148 
   239 // ---------------------------------------------------------------------------
   149 
   240 // CSifUi::ClearParamsL()
   150 
   241 // ---------------------------------------------------------------------------
   151 
   242 //
   152 // DEPRECATED FUNCTIONS -- TO BE REMOVED
   243 void CSifUi::ClearParamsL()
   153 
       
   154 EXPORT_C void CSifUi::SetMode( TMode /*aMode*/ )
   244     {
   155     {
   245     if( iVariantMap )
   156     User::Invariant();
   246         {
       
   247         delete iVariantMap;
       
   248         iVariantMap = NULL;
       
   249         }
       
   250     iVariantMap = CHbSymbianVariantMap::NewL();
       
   251     }
   157     }
   252 
   158 
   253 // ---------------------------------------------------------------------------
   159 EXPORT_C CSifUi::TMode CSifUi::Mode()
   254 // CSifUi::ChangeNoteTypeL()
       
   255 // ---------------------------------------------------------------------------
       
   256 //
       
   257 void CSifUi::ChangeNoteTypeL( TInt aType )
       
   258     {
   160     {
   259     ClearParamsL();
   161     User::Invariant();
   260     AddParamL( KSifUiDialogType, aType );
   162     return EUnspecified;
   261     AddParamL( KSifUiDialogMode, iMode );
       
   262     }
   163     }
   263 
   164 
   264 // ---------------------------------------------------------------------------
   165 EXPORT_C void CSifUi::ShowFailedL( TInt /*aErrorCode*/ )
   265 // CSifUi::AddParamL()
       
   266 // ---------------------------------------------------------------------------
       
   267 //
       
   268 void CSifUi::AddParamL( const TDesC& aKey, TInt aValue )
       
   269     {
   166     {
   270     CHbSymbianVariant* variant = NULL;
   167     User::Invariant();
   271     variant = CHbSymbianVariant::NewL( &aValue, CHbSymbianVariant::EInt );
       
   272     iVariantMap->Add( aKey, variant );
       
   273     }
   168     }
   274 
   169 
   275 // ---------------------------------------------------------------------------
       
   276 // CSifUi::AddParamL()
       
   277 // ---------------------------------------------------------------------------
       
   278 //
       
   279 void CSifUi::AddParamL( const TDesC& aKey, const TDesC& aValue )
       
   280     {
       
   281     CHbSymbianVariant* variant = NULL;
       
   282     variant = CHbSymbianVariant::NewL( &aValue, CHbSymbianVariant::EDes );
       
   283     iVariantMap->Add( aKey, variant );
       
   284     }
       
   285 
   170 
   286 // ---------------------------------------------------------------------------
       
   287 // CSifUi::AddParamsAppInfoAndSizeL()
       
   288 // ---------------------------------------------------------------------------
       
   289 //
       
   290 void CSifUi::AddParamsAppInfoAndSizeL( const Swi::CAppInfo& aAppInfo, TInt aAppSize )
       
   291     {
       
   292     AddParamL( KSifUiApplicationName, aAppInfo.AppName() );
       
   293     const TVersion& version( aAppInfo.AppVersion() );
       
   294     if( version.iBuild || version.iMajor || version.iMinor )
       
   295         {
       
   296         AddParamL( KSifUiApplicationVersion, version.Name() );
       
   297         }
       
   298     if( aAppInfo.AppVendor().Length() )
       
   299         {
       
   300         AddParamL( KSifUiApplicationDetails, aAppInfo.AppVendor() );
       
   301         }
       
   302     if( aAppSize > 0 )
       
   303         {
       
   304         AddParamL( KSifUiApplicationSize, aAppSize );
       
   305         }
       
   306     }
       
   307 
   171 
   308 // ---------------------------------------------------------------------------
       
   309 // CSifUi::AddParamsIconL()
       
   310 // ---------------------------------------------------------------------------
       
   311 //
       
   312 void CSifUi::AddParamsIconL( const CApaMaskedBitmap* aIcon )
       
   313     {
       
   314     if( aIcon )
       
   315         {
       
   316         if( iBitmap )
       
   317             {
       
   318             delete iBitmap;
       
   319             iBitmap = NULL;
       
   320             }
       
   321         iBitmap = CApaMaskedBitmap::NewL( aIcon );
       
   322 
       
   323         CHbSymbianVariant* variant = NULL;
       
   324         TInt bitmapHandle = iBitmap->Handle();
       
   325         variant = CHbSymbianVariant::NewL( &bitmapHandle, CHbSymbianVariant::EInt );
       
   326         iVariantMap->Add( KSifUiApplicationIconHandle, variant );
       
   327         TInt bitmapMaskHandle = iBitmap->Mask()->Handle();
       
   328         variant = CHbSymbianVariant::NewL( &bitmapMaskHandle, CHbSymbianVariant::EInt );
       
   329         iVariantMap->Add( KSifUiApplicationIconMaskHandle, variant );
       
   330         }
       
   331     }
       
   332 
       
   333 // ---------------------------------------------------------------------------
       
   334 // CSifUi::AddParamsCertificatesL()
       
   335 // ---------------------------------------------------------------------------
       
   336 //
       
   337 void CSifUi::AddParamsCertificatesL( const RPointerArray<Swi::CCertificateInfo>& /*aCertificates*/ )
       
   338     {
       
   339     // TODO: implement
       
   340     }
       
   341 
       
   342 // ---------------------------------------------------------------------------
       
   343 // CSifUi::DisplayDeviceDialogL()
       
   344 // ---------------------------------------------------------------------------
       
   345 //
       
   346 void CSifUi::DisplayDeviceDialogL()
       
   347     {
       
   348     if( iDeviceDialog && iIsDisplayingDialog )
       
   349         {
       
   350         iDeviceDialog->Update( *iVariantMap );
       
   351         }
       
   352     else
       
   353         {
       
   354         if( !iDeviceDialog )
       
   355             {
       
   356             iDeviceDialog = CHbDeviceDialog::NewL();
       
   357             }
       
   358         iDeviceDialog->Show( KSifUiDeviceDialog, *iVariantMap, this );
       
   359         iIsDisplayingDialog = ETrue;
       
   360         }
       
   361     }
       
   362 
       
   363 // ---------------------------------------------------------------------------
       
   364 // CSifUi::WaitForResponse()
       
   365 // ---------------------------------------------------------------------------
       
   366 //
       
   367 TInt CSifUi::WaitForResponse()
       
   368     {
       
   369     iCompletionCode = KErrInUse;
       
   370     iReturnValue = KErrUnknown;
       
   371     if( !IsActive() && iWait && !iWait->IsStarted() )
       
   372         {
       
   373         iStatus = KRequestPending;
       
   374         SetActive();
       
   375         iWait->Start();
       
   376         }
       
   377     return iCompletionCode;
       
   378     }
       
   379 
       
   380 // ---------------------------------------------------------------------------
       
   381 // CSifUi::ResponseReceived()
       
   382 // ---------------------------------------------------------------------------
       
   383 //
       
   384 void CSifUi::ResponseReceived( TInt aCompletionCode )
       
   385     {
       
   386     if( IsActive() )
       
   387         {
       
   388         iCompletionCode = aCompletionCode;
       
   389         TRequestStatus* status( &iStatus );
       
   390         User::RequestComplete( status, KErrNone );
       
   391         }
       
   392     }
       
   393