1 /*

     2 * Copyright (c) 2009 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:  HtiAppControl implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <apacmdln.h>

    21 #include <apgtask.h>

    22 #include <apgwgnam.h>

    23 #include <apmstd.h>

    24 

    25 #include <badesca.h>

    26 #include <f32file.h>

    27 

    28 #include "HtiAppControl.h"

    29 #include <HtiDispatcherInterface.h>

    30 #include <HtiLogging.h>

    31 

    32 #if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

    33 #include <SWInstApi.h>

    34 #include <swi/sisregistrysession.h>

    35 #include <swi/sisregistrypackage.h>

    36 #else

    37 #include <usif/sif/sif.h>

    38 #include <usif/scr/scr.h>    //RSoftwareComponentRegistry

    39 #endif

    40 #include <javaregistryincludes.h>

    41 #include <WidgetRegistryClient.h>

    42 

    43 using namespace Java;

    44 #if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_4 )

    45 _LIT8( KSisxMimeType, "x-epoc/x-sisx-app" );

    46 _LIT8( KSisMimeType, "application/vnd.symbian.install" );

    47 _LIT8( KPipMimeType, "application/x-pip" );

    48 _LIT8( KJadMIMEType, "text/vnd.sun.j2me.app-descriptor" );

    49 _LIT8( KJarMIMEType, "application/java-archive" );

    50 _LIT8( KJavaMIMEType, "application/java");

    51 _LIT8( KJarxMIMEType, "application/x-java-archive");

    52 #endif

    53 

    54 // CONSTANTS

    55 const static TUid KAppServiceUid = { 0x1020DEC7 }; //This is Uid of AppServiceOS

    56 

    57 //error descriptions

    58 _LIT8( KErrDescrNoMemory, "No memory" );

    59 _LIT8( KErrDescrInvalidCmd, "Invalid command" );

    60 _LIT8( KErrDescrInvalidArguments, "Invalid arguments" );

    61 _LIT8( KErrDescrFailedCreateProcess, "Failed create process" );

    62 _LIT8( KErrDescrNotSupported, "Command not supported" );

    63 

    64 _LIT8( KErrDescrFailedStartApp, "Failed start app" );

    65 _LIT8( KErrDescrInvalidUid, "Invalid application uid" );

    66 _LIT8( KErrDescrFailedFindApp, "Failed find app" );

    67 

    68 _LIT8( KErrDescrFailedConnectSilentInstaller, "Failed to connect to silent installer" );

    69 _LIT8( KErrDescrFailedInstall, "Failed to install" );

    70 _LIT8( KErrDescrFailedUnInstall, "Failed to uninstall" );

    71 _LIT8( KErrDescrFailedFindPackage, "Failed to find the package" );

    72 #if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_4 )

    73 _LIT8( KErrDescrBadComponentId, "Bad component id");

    74 #endif

    75 _LIT8( KErrDescrFailedListInstApps, "Failed to list installed apps" );

    76 

    77 const static TUint8 KUnicodeMask = 0x01;

    78 const static TInt KTerminateReason = 0;

    79 const static TInt KTUintLength = sizeof(TUint);

    80 const static TInt KCloseTaskDelay = 250000; // microseconds

    81 

    82 // MACROS

    83 

    84 // LOCAL CONSTANTS AND MACROS

    85 

    86 // MODULE DATA STRUCTURES

    87 

    88 // LOCAL FUNCTION PROTOTYPES

    89 

    90 // FORWARD DECLARATIONS

    91 

    92 // ============================ MEMBER FUNCTIONS ===============================

    93 CHtiAppControl* CHtiAppControl::NewL()

    94     {

    95     CHtiAppControl* self = new ( ELeave ) CHtiAppControl;

    96     CleanupStack::PushL( self );

    97     self->ConstructL();

    98     CleanupStack::Pop();

    99     return self;

   100     }

   101 

   102 // Constructor

   103 CHtiAppControl::CHtiAppControl():iIsAppCmdsSupported( EFalse )

   104     {

   105     }

   106 

   107 EXPORT_C CHtiAppControl* NewHtiAppControl()

   108     {

   109     return CHtiAppControl::NewL();

   110     }

   111 

   112 CHtiAppControl::~CHtiAppControl()

   113     {

   114     HTI_LOG_FUNC_IN( "~CHtiAppControl" );

   115 

   116     for ( TInt i = 0; i < iProcessHandleArray.Count(); i++ )

   117         {

   118         iProcessHandleArray[i].Close();

   119         }

   120     iProcessHandleArray.Close();

   121 

   122     iAppServer.Close();

   123     iWs.Close();

   124 

   125     if ( iMimeTypes )

   126         {

   127         iMimeTypes->Reset();

   128         delete iMimeTypes;

   129         }

   130 

   131 #if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

   132     iAugmentations.ResetAndDestroy();

   133 #endif

   134 

   135     HTI_LOG_FUNC_OUT( "~CHtiAppControl" );

   136     }

   137 

   138 // Second phase construction.

   139 void CHtiAppControl::ConstructL()

   140     {

   141     HTI_LOG_FUNC_IN( "CHtiAppControl::ConstructL" );

   142     iMimeTypes = new (ELeave) CDesC8ArrayFlat( 8 );

   143 #if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

   144     iMimeTypes->AppendL( SwiUI::KSisxMimeType() );

   145     iMimeTypes->AppendL( SwiUI::KSisMimeType() );

   146     iMimeTypes->AppendL( SwiUI::KPipMimeType() );

   147     iMimeTypes->AppendL( SwiUI::KJadMIMEType() );

   148     iMimeTypes->AppendL( SwiUI::KJarMIMEType() );

   149     iMimeTypes->AppendL( SwiUI::KJavaMIMEType() );

   150     iMimeTypes->AppendL( SwiUI::KJarxMIMEType() );

   151 #else

   152     iMimeTypes->AppendL( KSisxMimeType() );

   153     iMimeTypes->AppendL( KSisMimeType() );

   154     iMimeTypes->AppendL( KPipMimeType() );

   155     iMimeTypes->AppendL( KJadMIMEType() );

   156     iMimeTypes->AppendL( KJarMIMEType() );

   157     iMimeTypes->AppendL( KJavaMIMEType() );

   158     iMimeTypes->AppendL( KJarxMIMEType() );

   159 #endif

   160     iMimeTypes->AppendL( KWidgetMime() ); // from widgetregistryconstants.h

   161 #if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

   162     iAugmentationIndex = 0;

   163 #endif

   164 

   165     TInt err = iAppServer.Connect();

   166     if ( err == KErrNone )

   167         {

   168         err = iWs.Connect();

   169         }

   170     if ( err == KErrNone )

   171         {

   172         iIsAppCmdsSupported = ETrue;

   173         }

   174     else

   175         {

   176         iAppServer.Close();

   177         }

   178     HTI_LOG_FUNC_OUT( "CHtiAppControl::ConstructL" );

   179     }

   180 

   181 TInt CHtiAppControl::ParseString( const TDesC8& aRequest,

   182                                         TInt anOffset,

   183                                         TBool aUnicode,

   184                                         TDes& aResult )

   185     {

   186     HTI_LOG_FUNC_IN( "CHtiAppControl::ParseString" );

   187     //validate parameters

   188     //if offset outside the string return empty string

   189     if ( anOffset >= aRequest.Size() )

   190         {

   191         return anOffset;

   192         }

   193 

   194     TInt len = aRequest[anOffset];

   195     HTI_LOG_FORMAT( "length %d", len );

   196 

   197     if ( len > aResult.MaxLength() )

   198         {

   199         return KErrBadDescriptor;

   200         }

   201 

   202     TInt nextOffset = ( aUnicode ? len * 2 : len ) + anOffset + 1;

   203     HTI_LOG_FORMAT( "nextOffset %d", nextOffset );

   204     HTI_LOG_FORMAT( "reqSize %d", aRequest.Size() );

   205     if ( nextOffset > aRequest.Size() )

   206         {

   207         return KErrArgument;

   208         }

   209 

   210     if ( aUnicode )

   211         {

   212         const TPtrC8 aFrom( aRequest.Mid( anOffset + 1, len * 2 ) );

   213         aResult.SetLength( len );

   214         for ( TInt i = 0; i < len; ++i )

   215             {

   216             aResult[i] = ( TUint16 ) aFrom[i << 1] +

   217                 ( ( ( TUint16 ) aFrom[( i << 1 ) + 1] ) << 8 );

   218             }

   219         }

   220     else

   221         {

   222         aResult.Copy( aRequest.Mid( anOffset + 1, len ) );

   223         }

   224 

   225     HTI_LOG_FUNC_OUT( "CHtiAppControl::ParseString" );

   226     return nextOffset;

   227     }

   228 

   229 void CHtiAppControl::ProcessMessageL( const TDesC8& aMessage,

   230                 THtiMessagePriority /*aPriority*/ )

   231     {

   232     HTI_LOG_FUNC_IN( "CHtiAppControl::ProcessMessage" );

   233     if ( aMessage.Length() < 1 )

   234         {

   235         // no command

   236         SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

   237         return;

   238         }

   239 

   240     if ( aMessage.Length() < 2 &&

   241          aMessage[0] !=  EListInstalledApps &&

   242          aMessage[0] !=  EListInstalledApps_u)

   243         {

   244          // parameter is required with all commands except

   245          // listing processes or installed applications

   246         SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

   247         return;

   248         }

   249 

   250     HTI_LOG_FORMAT( "cmd %d", aMessage[0] );

   251 

   252     if ( aMessage[0] > EProcessLastCommand &&

   253               aMessage[0] < EAppLastCommand)

   254         {

   255         if ( iIsAppCmdsSupported )

   256             {

   257             HandleAppControlL( aMessage );

   258             }

   259         else

   260             {

   261             SendErrorMsg( KErrNotSupported, KErrDescrNotSupported );

   262             }

   263         }

   264     else if ( aMessage[0] > EAppLastCommand &&

   265               aMessage[0] < ESisLastCommand )

   266         {

   267         HandleInstallerControlL( aMessage );

   268         }

   269     else

   270         {

   271         SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

   272         }

   273     HTI_LOG_FUNC_OUT( "CHtiAppControl::ProcessMessage" );

   274     }

   275 

   276 void CHtiAppControl::HandleAppControlL( const TDesC8& aMessage )

   277     {

   278     HTI_LOG_FUNC_IN( "CHtiAppControl::HandleAppControl" );

   279 

   280     TBool unicode = aMessage[0] & KUnicodeMask;

   281 

   282     HTI_LOG_FORMAT( "unicode %d", unicode );

   283 

   284     TApaAppInfo appInfo;

   285     TFileName appName;

   286     TFileName docName;

   287 

   288     switch ( aMessage[0] )

   289         {

   290         case EStartApp_uid:

   291         case EStartApp_uid_u:

   292             {

   293             TPtrC8 parameters = aMessage.Mid( 1 );

   294             if ( parameters.Length() >= 4 )

   295                 {

   296                 TInt32 uid = Parse32<TInt32>( parameters );

   297 

   298                 TInt offset = ParseString( parameters, 4, unicode, docName );

   299                 if ( offset >= 0)

   300                     {

   301                     if ( FindAppL( appInfo, uid ) )

   302                         {

   303                         HandleStartAppL( appInfo, docName );

   304                         }

   305                     }

   306                 else

   307                     {

   308                     SendErrorMsg( offset , KErrDescrInvalidArguments );

   309                     }

   310                 }

   311             else

   312                 {

   313                 SendErrorMsg( KErrArgument , KErrDescrInvalidUid );

   314                 }

   315             }

   316             break;

   317         case EStartApp:

   318         case EStartApp_u:

   319             {

   320             TInt offset = ParseString( aMessage, 1, unicode, appName );

   321             if ( offset >= 0 )

   322                 {

   323                 offset = ParseString( aMessage, offset, unicode, docName );

   324                 if ( offset >= 0 )

   325                     {

   326                     //find appInfo by app full name

   327                     if ( FindAppL( appInfo, appName ) )

   328                         {

   329                         HTI_LOG_TEXT( "call HandleStartAppL" );

   330                         HandleStartAppL( appInfo, docName );

   331                         }

   332                     }

   333                 }

   334 

   335             if ( offset < 0 )

   336                 {

   337                 SendErrorMsg( offset , KErrDescrInvalidArguments );

   338                 }

   339             }

   340             break;

   341         case EStartDoc:

   342         case EStartDoc_u:

   343             {

   344             TInt offset = ParseString( aMessage, 1, unicode, docName );

   345             if ( offset >= 0 )

   346                 {

   347                 HandleStartAppL( appInfo, docName ); //appInfo is empty

   348                 }

   349             else

   350                 {

   351                 SendErrorMsg( offset , KErrDescrInvalidArguments );

   352                 }

   353             }

   354             break;

   355         case EStatusApp_uid:

   356             {

   357             TPtrC8 appUid8 = aMessage.Mid( 1 );

   358             if ( appUid8.Length() == 4 )

   359                 {

   360                 TApaTaskList tl( iWs );

   361                 TInt32 appUid = Parse32<TInt32>( appUid8 );

   362                 TApaTask task = tl.FindApp( TUid::Uid( appUid ) );

   363                 if ( task.Exists() )

   364                     {

   365                     SendMessageL( ERunning );

   366                     }

   367                 else

   368                     {

   369                     SendMessageL( ENotFound );

   370                     }

   371                 }

   372             else

   373                 {

   374                 SendErrorMsg( KErrArgument, KErrDescrInvalidUid );

   375                 }

   376             }

   377             break;

   378         case EStatusApp:

   379         case EStatusApp_u:

   380             {

   381             TInt offset = ParseString( aMessage, 1, unicode, appName );

   382             if ( offset >= 0 )

   383                 {

   384                 TApaTaskList tl( iWs );

   385                 TApaTask task = tl.FindApp( appName );

   386                 if ( task.Exists() )

   387                     {

   388                     SendMessageL( ERunning );

   389                     break; // we are done

   390                     }

   391 

   392                 // Maybe the user gave path or filename instead of caption

   393                 if ( FindAppL( appInfo, appName ) )

   394                     {

   395                     TApaTask task2 = tl.FindApp( appInfo.iUid );

   396                     if ( task2.Exists() )

   397                         {

   398                         SendMessageL( ERunning );

   399                         }

   400                     else

   401                         {

   402                         SendMessageL( ENotFound );

   403                         }

   404                     }

   405                 // If app was not found by FindAppL method, a response message

   406                 // has already been sent there - no need to send anything here.

   407                 }

   408             else

   409                 {

   410                 SendErrorMsg( offset , KErrDescrInvalidArguments );

   411                 }

   412             }

   413             break;

   414         case EStatusDoc:

   415         case EStatusDoc_u:

   416             {

   417             TInt offset = ParseString( aMessage, 1, unicode, docName );

   418             if ( offset >= 0 )

   419                 {

   420                 TApaTaskList tl( iWs );

   421                 TApaTask task = tl.FindDoc( docName );

   422                 if ( task.Exists() )

   423                     {

   424                     SendMessageL( ERunning );

   425                     }

   426                 else

   427                     {

   428                     SendMessageL( ENotFound );

   429                     }

   430                 }

   431             else

   432                 {

   433                 SendErrorMsg( offset , KErrDescrInvalidArguments );

   434                 }

   435             }

   436             break;

   437         case EStopApp:

   438         case EStopApp_u:

   439             {

   440             TInt offset = ParseString( aMessage, 1, unicode, appName );

   441             if ( offset >= 0 )

   442                 {

   443                 TApaTaskList tl( iWs );

   444                 TApaTask task = tl.FindApp( appName );

   445                 if ( task.Exists() )

   446                     {

   447                     task.EndTask();

   448                     User::After( KCloseTaskDelay );

   449                     TApaTask task = tl.FindApp( appName );

   450                     if ( task.Exists() )

   451                         {

   452                         task.KillTask();

   453                         }

   454                     SendMessageL( EOk );

   455                     break; // we are done

   456                     }

   457 

   458                 // Maybe the user gave path or filename instead of caption

   459                 if ( FindAppL( appInfo, appName ) )

   460                     {

   461                     TApaTask task2 = tl.FindApp( appInfo.iUid );

   462                     if ( task2.Exists() )

   463                         {

   464                         task2.EndTask();

   465                         User::After( KCloseTaskDelay );

   466                         TApaTask task2 = tl.FindApp( appInfo.iUid );

   467                         if ( task2.Exists() )

   468                             {

   469                             task2.KillTask();

   470                             }

   471                         SendMessageL( EOk );

   472                         }

   473                     else

   474                         {

   475                         SendMessageL( ENotFound );

   476                         }

   477                     }

   478                 // If app was not found by FindAppL method, a response message

   479                 // has already been sent there - no need to send anything here.

   480                 }

   481             else

   482                 {

   483                 SendErrorMsg( offset , KErrDescrInvalidArguments );

   484                 }

   485             }

   486             break;

   487         case EStopDoc:

   488         case EStopDoc_u:

   489             {

   490             TInt offset = ParseString( aMessage, 1, unicode, docName );

   491             if ( offset >= 0 )

   492                 {

   493                 TApaTaskList tl( iWs );

   494                 TApaTask task = tl.FindDoc( docName );

   495                 if ( task.Exists() )

   496                     {

   497                     task.EndTask();

   498                     User::After( KCloseTaskDelay );

   499                     TApaTask task = tl.FindDoc( docName );

   500                     if ( task.Exists() )

   501                         {

   502                         task.KillTask();

   503                         }

   504                     SendMessageL( EOk );

   505                     }

   506                 else

   507                     {

   508                     SendMessageL( ENotFound );

   509                     }

   510                 }

   511             else

   512                 {

   513                 SendErrorMsg( offset , KErrDescrInvalidArguments );

   514                 }

   515             }

   516             break;

   517         case EStopApp_uid:

   518             {

   519             TPtrC8 appUid8 = aMessage.Mid( 1 );

   520             if ( appUid8.Length() == 4 )

   521                 {

   522                 TApaTaskList tl( iWs );

   523                 TInt32 appUid = Parse32<TInt32>( appUid8 );

   524                 TApaTask task = tl.FindApp( TUid::Uid( appUid ) );

   525                 if ( task.Exists() )

   526                     {

   527                     task.EndTask();

   528                     User::After(KCloseTaskDelay);

   529                     TApaTask task = tl.FindApp( TUid::Uid( appUid ) );

   530                     if ( task.Exists() )

   531                         {

   532                         task.KillTask();

   533                         }

   534                     SendMessageL( EOk );

   535                     }

   536                 else

   537                     {

   538                     SendMessageL( ENotFound );

   539                     }

   540                 }

   541             else

   542                 {

   543                 SendErrorMsg( KErrArgument , KErrDescrInvalidUid );

   544                 }

   545             }

   546             break;

   547         case EListApps:

   548         case EListApps_u:

   549             {

   550             if ( aMessage.Length() != 3 )

   551                 {

   552                 SendErrorMsg( KErrArgument, KErrDescrInvalidArguments );

   553                 }

   554             else

   555                 {

   556                 HandleListAppsL( aMessage[1], aMessage[2], unicode );

   557                 }

   558             }

   559             break;

   560         case EListInstalledApps:

   561         case EListInstalledApps_u:

   562             {

   563             if ( aMessage.Length() != 1 )

   564                 {

   565                 SendErrorMsg( KErrArgument, KErrDescrInvalidArguments );

   566                 }

   567             else

   568                 {

   569                 HandleListInstalledAppsL( unicode );

   570                 }

   571             }

   572             break;

   573         default:

   574             {

   575             SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

   576             }

   577         }

   578 

   579     HTI_LOG_FUNC_OUT("CHtiAppControl::HandleAppControl");

   580     }

   581 

   582 void CHtiAppControl::HandleInstallerControlL( const TDesC8& aMessage )

   583     {

   584     HTI_LOG_FUNC_IN( "CHtiAppControl::HandleInstallerControlL" );

   585 

   586     if ( aMessage.Length() < 2 )

   587         {

   588         HTI_LOG_TEXT( "Command parameters missing" );

   589         SendErrorMsg( KErrArgument , KErrDescrInvalidCmd );

   590         return;

   591         }

   592 

   593     TBool unicode = aMessage[0] & KUnicodeMask;

   594     HTI_LOG_FORMAT( "Unicode flag: %d", unicode );

   595 

   596     TFileName path;

   597 #if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

   598     TBuf<SwiUI::KSWInstMaxPasswordLength> login;

   599     TBuf<SwiUI::KSWInstMaxPasswordLength> password;

   600 #endif

   601 

   602     switch ( aMessage[0] )

   603         {

   604         case EInstall:

   605         case EInstall_u:

   606             {

   607             TPtrC8 parameters = aMessage.Mid( 1 );

   608             if ( ValidateInstallParams( parameters, unicode ) )

   609                 {

   610                 TInt offset = ParseString( parameters, 0, unicode, path );

   611 

   612                 HTI_LOG_TEXT( "Parsed path to install package:" );

   613                 HTI_LOG_DES( path )

   614 

   615                 if ( offset >= 0)

   616                     {

   617 #if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

   618                     iInstOpts = SwiUI::TInstallOptions();

   619 

   620                     iInstOpts.iUpgrade =            ConvertToPolicy( parameters[offset] ); offset++;

   621                     iInstOpts.iOptionalItems =      ConvertToPolicy( parameters[offset] ); offset++;

   622                     iInstOpts.iOCSP =               ConvertToPolicy( parameters[offset] ); offset++;

   623                     iInstOpts.iIgnoreOCSPWarnings = ConvertToPolicy( parameters[offset] ); offset++;

   624                     iInstOpts.iUntrusted =          ConvertToPolicy( parameters[offset] ); offset++;

   625                     iInstOpts.iPackageInfo =        ConvertToPolicy( parameters[offset] ); offset++;

   626                     iInstOpts.iCapabilities =       ConvertToPolicy( parameters[offset] ); offset++;

   627                     iInstOpts.iKillApp =            ConvertToPolicy( parameters[offset] ); offset++;

   628                     iInstOpts.iOverwrite =          ConvertToPolicy( parameters[offset] ); offset++;

   629                     iInstOpts.iDownload =           ConvertToPolicy( parameters[offset] ); offset++;

   630 

   631                     HTI_LOG_FORMAT( "iUpgrade: %d",            iInstOpts.iUpgrade );

   632                     HTI_LOG_FORMAT( "iOptionalItems: %d",      iInstOpts.iOptionalItems );

   633                     HTI_LOG_FORMAT( "iOCSP: %d",               iInstOpts.iOCSP );

   634                     HTI_LOG_FORMAT( "iIgnoreOCSPWarnings: %d", iInstOpts.iIgnoreOCSPWarnings );

   635                     HTI_LOG_FORMAT( "iUntrusted: %d",          iInstOpts.iUntrusted );

   636                     HTI_LOG_FORMAT( "iPackageInfo: %d",        iInstOpts.iPackageInfo );

   637                     HTI_LOG_FORMAT( "iCapabilities: %d",       iInstOpts.iCapabilities );

   638                     HTI_LOG_FORMAT( "iKillApp: %d",            iInstOpts.iKillApp );

   639                     HTI_LOG_FORMAT( "iOverwrite: %d",          iInstOpts.iOverwrite );

   640                     HTI_LOG_FORMAT( "iDownload: %d",           iInstOpts.iDownload );

   641 

   642                     offset = ParseString( parameters, offset, unicode, login );

   643                     iInstOpts.iLogin.Copy( login );

   644                     HTI_LOG_TEXT( "Parsed login:" );

   645                     HTI_LOG_DES( login )

   646 

   647                     offset = ParseString( parameters, offset, unicode, password );

   648                     iInstOpts.iPassword.Copy( password );

   649                     HTI_LOG_TEXT( "Parsed password:" );

   650                     HTI_LOG_DES( password )

   651 

   652                     iInstOpts.iDrive =        (TChar) parameters[offset]; offset++;

   653                     iInstOpts.iLang =         (TLanguage) parameters[offset]; offset++;

   654                     iInstOpts.iUsePhoneLang = (TBool) parameters[offset]; offset++;

   655                     iInstOpts.iUpgradeData =  ConvertToPolicy( parameters[offset] );

   656                     offset++;

   657                     HTI_LOG_FORMAT( "parameters length: %d", parameters.Length());

   658                     HTI_LOG_FORMAT( "next offset: %d", offset);

   659 

   660                     if(parameters.Length() > offset)

   661                         {

   662                         TInt language = iInstOpts.iLang;

   663                         if (parameters.Length() == offset+2)

   664                             {

   665                             language = parameters[offset] + (parameters[offset+1]<<8);

   666                             }

   667                         if (parameters.Length() == offset+1)

   668                             {

   669                             language = parameters[offset];

   670                             }

   671                         if ((language > ELangTest) && (language < ELangMaximum))

   672                             {

   673                             iInstOpts.iLang =         (TLanguage) language;

   674                             }

   675                         }

   676                     HTI_LOG_FORMAT( "iDrive: %c",        iInstOpts.iDrive.GetLowerCase() );

   677                     HTI_LOG_FORMAT( "iLang: %d",         iInstOpts.iLang );

   678                     HTI_LOG_FORMAT( "iUsePhoneLang: %d", iInstOpts.iUsePhoneLang );

   679                     HTI_LOG_FORMAT( "iUpgradeData: %d",  iInstOpts.iUpgradeData );

   680 

   681                     iInstOptsPckg = iInstOpts;

   682 

   683                     // Connect to silent installer

   684                     SwiUI::RSWInstSilentLauncher launcher;

   685                     TInt err = launcher.Connect();

   686                     if ( err )

   687                         {

   688                         HTI_LOG_FORMAT( "Error connecting to silent installer, err: %d", err );

   689                         SendErrorMsg( err , KErrDescrFailedConnectSilentInstaller );

   690                         break;

   691                         }

   692 

   693                     err = launcher.SilentInstall( path, iInstOptsPckg );

   694                     if ( err )

   695                         {

   696                         HTI_LOG_FORMAT( "Error installing software, err: %d", err );

   697                         launcher.Close();

   698                         SendErrorMsg( err , KErrDescrFailedInstall );

   699                         break;

   700                         }

   701 

   702                     launcher.Close();

   703                     SendMessageL( EOk );

   704 #else

   705                     HTI_LOG_TEXT( "============RSoftwareInstall::Install=============" );

   706                     Usif::RSoftwareInstall installer;

   707                     TInt err = installer.Connect();

   708                     if(err)

   709                         {

   710                         SendErrorMsg( err , KErrDescrFailedConnectSilentInstaller );

   711                         HTI_LOG_FORMAT("cannot connect to SIF server, err %d", err);

   712                         User::Leave(err);

   713                         }

   714                     CleanupClosePushL(installer);

   715                     TRequestStatus status;

   716                     Usif::COpaqueNamedParams *arguments = Usif::COpaqueNamedParams::NewL();

   717                     CleanupStack::PushL(arguments);

   718                     Usif::COpaqueNamedParams *results = Usif::COpaqueNamedParams::NewL();

   719                     CleanupStack::PushL(results);

   720                     

   721                     arguments->AddIntL(Usif::KSifInParam_InstallSilently, ETrue);

   722                     

   723                     TInt intValue = ConvertToSifPolicy(parameters[offset]); offset++;

   724                     if(intValue != Usif::EAllowed)

   725                         arguments->AddIntL(Usif::KSifInParam_AllowUpgrade, intValue);

   726                     HTI_LOG_FORMAT( "iUpgrade: %d", intValue );

   727                     intValue = ConvertToSifPolicy(parameters[offset]); offset++; 

   728                     if(intValue != Usif::EAllowed)

   729                         arguments->AddIntL(Usif::KSifInParam_InstallOptionalItems, intValue);

   730                     HTI_LOG_FORMAT( "iOptionalItems: %d", intValue );

   731                     intValue = ConvertToSifPolicy(parameters[offset]); offset++;

   732                     if(intValue != Usif::EAllowed)

   733                         arguments->AddIntL(Usif::KSifInParam_PerformOCSP, intValue);

   734                     HTI_LOG_FORMAT( "iOCSP: %d", intValue );

   735                     intValue = ConvertToSifPolicy(parameters[offset]); offset++;

   736                     if(intValue != Usif::EAllowed)

   737                         arguments->AddIntL(Usif::KSifInParam_IgnoreOCSPWarnings, intValue);

   738                     HTI_LOG_FORMAT( "iIgnoreOCSPWarnings: %d", intValue );

   739                     intValue = ConvertToSifPolicy(parameters[offset]); offset++;

   740                     if(intValue != Usif::ENotAllowed)

   741                         arguments->AddIntL(Usif::KSifInParam_AllowUntrusted, intValue);

   742                     HTI_LOG_FORMAT( "iUntrusted: %d", intValue );

   743                     intValue = ConvertToSifPolicy(parameters[offset]); offset++;

   744                     if(intValue != Usif::EAllowed)

   745 						arguments->AddIntL(Usif::KSifInParam_PackageInfo, intValue);

   746                     HTI_LOG_FORMAT( "iPackageInfo: %d", intValue );

   747                     intValue = ConvertToSifPolicy(parameters[offset]); offset++;

   748                     if(intValue != Usif::EAllowed)

   749                         arguments->AddIntL(Usif::KSifInParam_GrantCapabilities,intValue);

   750                     HTI_LOG_FORMAT( "iCapabilities: %d", intValue );

   751                     intValue = ConvertToSifPolicy(parameters[offset]); offset++;

   752                     if(intValue != Usif::EAllowed)

   753                         arguments->AddIntL(Usif::KSifInParam_AllowAppShutdown,intValue);

   754                     HTI_LOG_FORMAT( "iKillApp: %d", intValue );

   755                     intValue = ConvertToSifPolicy(parameters[offset]); offset++;

   756                     if(intValue != Usif::EAllowed)

   757                         arguments->AddIntL(Usif::KSifInParam_AllowOverwrite,intValue);

   758                     HTI_LOG_FORMAT( "iOverwrite: %d", intValue );

   759                     intValue = ConvertToSifPolicy(parameters[offset]); offset++;

   760                     if(intValue != Usif::EAllowed)

   761                         arguments->AddIntL(Usif::KSifInParam_AllowDownload, intValue);

   762                     HTI_LOG_FORMAT( "iDownload: %d", intValue );

   763 

   764                     TBuf<32> login;

   765                     offset = ParseString( parameters, offset, unicode, login );

   766                     HTI_LOG_FORMAT( "login length: %d", login.Length() );

   767                     if(login != KNullDesC)

   768                         {

   769                         arguments->AddStringL(Usif::KSifInParam_UserName, login);

   770                         }

   771                     HTI_LOG_TEXT( "Parsed login:" );

   772                     HTI_LOG_DES( login )

   773 

   774                     TBuf<32> password;

   775                     offset = ParseString( parameters, offset, unicode, password );

   776                     HTI_LOG_FORMAT( "password length: %d", password.Length() );

   777                     if(password != KNullDesC)

   778                         {

   779                         arguments->AddStringL(Usif::KSifInParam_Password, password );

   780                         }

   781                     HTI_LOG_TEXT( "Parsed password:" );

   782                     HTI_LOG_DES( password )

   783 

   784                     TChar driver = (TChar) parameters[offset]; offset++;

   785                     if(driver >= 'A' && driver <= 'Z')

   786                         {

   787                         intValue = driver - (TChar)'A';

   788                         arguments->AddIntL(Usif::KSifInParam_Drive, intValue);

   789                         HTI_LOG_FORMAT( "iDrive: %c", intValue + 'a' );

   790                         }

   791                     else if(driver >= 'a' && driver <= 'z')

   792                         {

   793                         intValue = driver - (TChar)'a';

   794                         arguments->AddIntL(Usif::KSifInParam_Drive, intValue);

   795                         HTI_LOG_FORMAT( "iDrive: %c", intValue + 'a' );

   796                         }

   797 

   798                     TLanguage oldFormatLanuage = (TLanguage)parameters[offset]; offset++;

   799 

   800                     TBool usePhoneLang = (TBool)parameters[offset]; offset++;

   801                     HTI_LOG_FORMAT( "iUsePhoneLang: %d", usePhoneLang );

   802 

   803                     intValue =  ConvertToSifPolicy( parameters[offset] );offset++;

   804                     /*if(intValue != Usif::EAllowed)

   805                         arguments->AddIntL(Usif::KSifInParam_AllowUpgrade, intValue);*/

   806                     HTI_LOG_FORMAT( "iUpgradeData: %d",  intValue ); 

   807                     

   808                     HTI_LOG_FORMAT( "parameters length: %d", parameters.Length());

   809                     HTI_LOG_FORMAT( "next offset: %d", offset);

   810 

   811                     if(usePhoneLang == EFalse)

   812                         {

   813                         if(parameters.Length() > offset)

   814                             {

   815                             TLanguage language = ELangTest;

   816                             if (parameters.Length() == offset+2)

   817                                 {

   818                                 language = (TLanguage)(parameters[offset] + (parameters[offset+1]<<8));

   819                                 }

   820                             else if (parameters.Length() == offset+1)

   821                                 {

   822                                 language = (TLanguage)(parameters[offset]);

   823                                 }

   824                             if ((language > ELangTest) && (language < ELangMaximum))

   825                                 {

   826                                 arguments->AddIntL(Usif::KSifInParam_Languages, language);

   827                                 HTI_LOG_FORMAT( "iLang: %d", language );

   828                                 }

   829                             }

   830                         else

   831                             {

   832                             arguments->AddIntL(Usif::KSifInParam_Languages, oldFormatLanuage);

   833                             HTI_LOG_FORMAT( "iLang0: %d", oldFormatLanuage );

   834                             }

   835                         }

   836 

   837                     installer.Install(path, *arguments, *results, status);

   838                     User::WaitForRequest(status);

   839                     HTI_LOG_FORMAT("install status: %d", status.Int());

   840                     TInt componentId = 0;

   841                     TBool idExisted = results->GetIntByNameL(Usif::KSifOutParam_ComponentId, componentId);

   842                     if ( idExisted )

   843                         {

   844                         HTI_LOG_FORMAT( "componentId:%d", componentId);

   845                         }

   846                     CleanupStack::PopAndDestroy(3);

   847                     if (status != KErrNone)

   848                         {

   849                         SendErrorMsg( status.Int(), KErrDescrFailedInstall );

   850                         break;

   851                         }

   852                     SendMessageL( EOk );

   853 #endif

   854                     }

   855                 else

   856                     {

   857                     HTI_LOG_TEXT( "Error parsing path" );

   858                     SendErrorMsg( offset , KErrDescrInvalidArguments );

   859                     }

   860                 }

   861             else

   862                 {

   863                 SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

   864                 }

   865             }

   866             break;

   867 

   868         case EUnInstall:

   869         case EUnInstallName:

   870         case EUnInstallName_u:

   871             {

   872             TPtrC8 parameters = aMessage.Mid( 1 );

   873             if ( ( aMessage[0] == EUnInstall && parameters.Length() != 7 ) ||

   874                  ( aMessage[0] == EUnInstallName &&

   875                    parameters.Length() != parameters[0] + 4 ) ||

   876                  ( aMessage[0] == EUnInstallName_u &&

   877                    parameters.Length() != parameters[0] * 2 + 4 ) )

   878                 {

   879                 HTI_LOG_FORMAT( "Invalid command length: %d",

   880                     parameters.Length() );

   881                 SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

   882                 break;

   883                 }

   884 

   885             TInt offset = 0;

   886             TInt32 uid = KErrNotFound;

   887             HBufC* packageName = NULL;

   888 #if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_4 )

   889             Usif::TComponentId cid = KErrNotFound; 

   890             HTI_LOG_TEXT( "============RSoftwareInstall::Uninstall=============" );

   891             Usif::RSoftwareInstall installer;

   892             TInt err = installer.Connect();

   893             if(err)

   894                 {

   895                 SendErrorMsg( err , KErrDescrFailedConnectSilentInstaller );

   896                 HTI_LOG_FORMAT("cannot connect to SIF server, err %d", err);

   897                 User::Leave(err);

   898                 }

   899             CleanupClosePushL(installer);

   900             TRequestStatus status;

   901             Usif::COpaqueNamedParams *arguments = Usif::COpaqueNamedParams::NewL();

   902             CleanupStack::PushL(arguments);

   903             Usif::COpaqueNamedParams *results = Usif::COpaqueNamedParams::NewL();

   904             CleanupStack::PushL(results);

   905 #endif

   906             if ( aMessage[0] == EUnInstall )

   907                 {

   908                 uid = Parse32<TInt32>( parameters );

   909                 offset += 4;

   910                 HTI_LOG_FORMAT( "Uninstall by uid: %d", uid );

   911 #if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_4 )

   912                 cid = GetComponentIdFromUid(uid);

   913                 if ( cid == KErrNotFound )

   914                     {

   915                     HTI_LOG_FORMAT( "cid: %d", cid );

   916                     SendErrorMsg( KErrNotFound, KErrDescrBadComponentId );

   917                     CleanupStack::PopAndDestroy(3); //results, arguments, installer

   918                     break;

   919                     }

   920 #endif

   921                 }

   922             else

   923                 {

   924                 packageName = HBufC::NewLC( parameters[offset] );

   925                 TPtr namePtr = packageName->Des();

   926                 offset = ParseString( parameters, offset, unicode, namePtr );

   927                 HTI_LOG_FORMAT( "Uninstall by name: %S", packageName );

   928 #if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_4 )

   929                 cid = GetComponentIdFromPackageName(*packageName);

   930                 CleanupStack::PopAndDestroy(); // packageName

   931                 if ( cid == KErrNotFound )

   932                     {

   933                     HTI_LOG_FORMAT( "cid: %d", cid );

   934                     SendErrorMsg( KErrNotFound, KErrDescrFailedFindPackage );

   935                     CleanupStack::PopAndDestroy(3); //results, arguments, installer

   936                     break;

   937                     }

   938 #endif

   939                 }

   940 #if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

   941             iUnInstOpts = SwiUI::TUninstallOptions();

   942             iUnInstOpts.iKillApp = ConvertToPolicy( parameters[offset] );

   943             offset++;

   944             iUnInstOpts.iBreakDependency = ConvertToPolicy( parameters[offset] );

   945             offset++;

   946             HTI_LOG_FORMAT( "iKillApp: %d",         iUnInstOpts.iKillApp );

   947             HTI_LOG_FORMAT( "iBreakDependency: %d", iUnInstOpts.iBreakDependency );

   948 

   949             TInt mimeIndex = parameters[offset];

   950             if ( mimeIndex > iMimeTypes->Count() - 1 )

   951                 {

   952                 HTI_LOG_FORMAT( "Invalid mime type: %d", mimeIndex );

   953                 SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

   954                 break;

   955                 }

   956 

   957             HTI_LOG_TEXT( "Uninstall mime type:" );

   958             HTI_LOG_DES( (*iMimeTypes)[mimeIndex] );

   959 

   960             TInt err = KErrNone;

   961             iAugmentationIndex = 0;

   962             if ( packageName )

   963                 {

   964                 TRAP( err, uid = GetPackageUidL( *packageName, mimeIndex ) );

   965                 CleanupStack::PopAndDestroy(); // packageName

   966                 iAugmentations.ResetAndDestroy();

   967                 if ( err != KErrNone )

   968                     {

   969                     SendErrorMsg( err, KErrDescrFailedFindPackage );

   970                     break;

   971                     }

   972                 }

   973             HTI_LOG_FORMAT( "UID = %d", uid );

   974 

   975             iUnInstOptsPckg = iUnInstOpts;

   976 

   977             // Connect to silent installer

   978             SwiUI::RSWInstSilentLauncher launcher;

   979             err = launcher.Connect();

   980             if ( err )

   981                 {

   982                 HTI_LOG_FORMAT( "Error connecting to silent installer, err: %d", err );

   983                 SendErrorMsg( err , KErrDescrFailedConnectSilentInstaller );

   984                 break;

   985                 }

   986 

   987             if ( iAugmentationIndex > 0 )

   988                 {

   989                 SwiUI::TOpUninstallIndexParam params;

   990                 params.iUid = TUid::Uid( uid );

   991                 params.iIndex = iAugmentationIndex;

   992                 SwiUI::TOpUninstallIndexParamPckg paramPckg( params );

   993                 SwiUI::TOperation operation( SwiUI::EOperationUninstallIndex );

   994                 err = launcher.SilentCustomUninstall( operation, iUnInstOptsPckg,

   995                     paramPckg, (*iMimeTypes)[mimeIndex] );

   996                 }

   997             else

   998                 {

   999                 err = launcher.SilentUninstall( TUid::Uid( uid ), iUnInstOptsPckg,

  1000                         (*iMimeTypes)[mimeIndex] );

  1001                 }

  1002 

  1003             if ( err )

  1004                 {

  1005                 HTI_LOG_FORMAT( "Error uninstalling software, err: %d", err );

  1006                 launcher.Close();

  1007                 SendErrorMsg( err , KErrDescrFailedUnInstall );

  1008                 break;

  1009                 }

  1010 

  1011             launcher.Close();

  1012 #else

  1013             

  1014             TInt intValue = ConvertToSifPolicy( parameters[offset] );

  1015             offset++;

  1016             arguments->AddIntL(Usif::KSifInParam_AllowAppShutdown, intValue);

  1017             HTI_LOG_FORMAT( "iKillApp: %d", intValue );

  1018             intValue = ConvertToSifPolicy( parameters[offset] );

  1019             offset++;

  1020             arguments->AddIntL(Usif::KSifInParam_AllowAppBreakDependency, intValue);

  1021             HTI_LOG_FORMAT( "iBreakDependency: %d", intValue );

  1022 

  1023             TInt mimeIndex = parameters[offset];

  1024             if ( mimeIndex > iMimeTypes->Count() - 1 )

  1025                 {

  1026                 HTI_LOG_FORMAT( "Invalid mime type: %d", mimeIndex );

  1027                 SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

  1028                 break;

  1029                 }

  1030 

  1031             HTI_LOG_TEXT( "Uninstall mime type:" );

  1032             HTI_LOG_DES( (*iMimeTypes)[mimeIndex] );

  1033 

  1034             HBufC* buf = HBufC::NewLC((*iMimeTypes)[mimeIndex].Length());

  1035             TPtr ptr = buf->Des();

  1036             ptr.Copy((*iMimeTypes)[mimeIndex]);

  1037             arguments->AddStringL(Usif::KSifInParam_MimeType, *buf);

  1038             CleanupStack::PopAndDestroy(); // buf

  1039       

  1040             HTI_LOG_FORMAT( "Component ID = %d", cid );

  1041             

  1042             arguments->AddIntL(Usif::KSifInParam_InstallSilently, ETrue);

  1043             

  1044             installer.Uninstall(cid, *arguments, *results, status, EFalse);

  1045             User::WaitForRequest(status);

  1046             HTI_LOG_FORMAT("uninstall status:%d", status.Int());

  1047             CleanupStack::PopAndDestroy(3); //results, arguments, installer

  1048             if (status != KErrNone)

  1049                 {

  1050                 SendErrorMsg(status.Int(), KErrDescrFailedUnInstall);

  1051                 break;

  1052                 }            

  1053 #endif

  1054             SendMessageL( EOk );

  1055             }

  1056             break;

  1057 

  1058         default:

  1059             {

  1060             SendErrorMsg( KErrArgument, KErrDescrInvalidCmd );

  1061             }

  1062         }

  1063 

  1064     HTI_LOG_FUNC_OUT( "CHtiAppControl::HandleInstallerControlL" );

  1065     }

  1066 

  1067 

  1068 void CHtiAppControl::HandleStartProcessL( const TDesC& aProgramName,

  1069                                                 const TDesC& aCmdLine,

  1070                                                 TBool aStoreProcessHandle )

  1071     {

  1072     HTI_LOG_FUNC_IN( "CHtiAppControl::HandleStartProcessL" );

  1073     HTI_LOG_FORMAT( "progr name %d", aProgramName.Length() );

  1074     HTI_LOG_DES( aProgramName );

  1075 

  1076     RProcess process;

  1077     TInt err = process.Create( aProgramName, aCmdLine ); // command parameters

  1078 

  1079     if ( err == KErrNone )

  1080         {

  1081         CleanupClosePushL( process );

  1082 

  1083         //convert process id to binary des

  1084         TUint processId = process.Id();

  1085         HTI_LOG_FORMAT( "process id %d", processId );

  1086 

  1087         TBuf8<KTUintLength> processIdDes;

  1088         processIdDes.Append(

  1089                 ( TUint8* )( &processId ), KTUintLength );

  1090 

  1091         SendMessageL( EOk, processIdDes );

  1092 

  1093         process.Resume();

  1094 

  1095         if ( aStoreProcessHandle )

  1096             {

  1097             HTI_LOG_TEXT( "Storing the process handle" );

  1098             iProcessHandleArray.Append( process );

  1099             CleanupStack::Pop();

  1100             }

  1101         else

  1102             {

  1103             CleanupStack::PopAndDestroy();

  1104             }

  1105         }

  1106     else if ( err == KErrNotFound )

  1107         {

  1108         SendMessageL( ENotFound );

  1109         }

  1110     else

  1111         {

  1112         SendErrorMsg( err ,KErrDescrFailedCreateProcess );

  1113         }

  1114 

  1115     HTI_LOG_FUNC_OUT( "CHtiAppControl::HandleStartProcessL" );

  1116     }

  1117 

  1118 void CHtiAppControl::HandleStopProcessL( RProcess& aProcess )

  1119     {

  1120     if ( aProcess.ExitType() == EExitPending )

  1121         {

  1122         aProcess.Kill( KTerminateReason );

  1123         SendMessageL( EOk );

  1124         }

  1125     else

  1126         {

  1127         SendMessageL( EAlreadyStopped );

  1128         }

  1129     }

  1130 

  1131 void CHtiAppControl::HandleStatusProcessL( RProcess& aProcess )

  1132     {

  1133     TExitType exT = aProcess.ExitType();

  1134