contentstorage/cahandler/app/src/caapphandler.cpp
changeset 89 1e87eb3b400f
parent 88 7f0462e8c3da
child 92 782e3408c2ab
equal deleted inserted replaced
88:7f0462e8c3da 89:1e87eb3b400f
    25 #include <AknTaskList.h>
    25 #include <AknTaskList.h>
    26 
    26 
    27 #include "caapphandler.h"
    27 #include "caapphandler.h"
    28 #include "cainnerentry.h"
    28 #include "cainnerentry.h"
    29 #include "cauninstalloperation.h"
    29 #include "cauninstalloperation.h"
       
    30 #include"catasklist.h"
    30 
    31 
    31 #include "cautils.h"
    32 #include "cautils.h"
    32 #include "cadef.h"
    33 #include "cadef.h"
    33 
    34 
    34 // ======== MEMBER FUNCTIONS ========
    35 // ======== MEMBER FUNCTIONS ========
    47 // ---------------------------------------------------------------------------
    48 // ---------------------------------------------------------------------------
    48 //
    49 //
    49 CCaAppHandler *CCaAppHandler::NewL()
    50 CCaAppHandler *CCaAppHandler::NewL()
    50 {
    51 {
    51     CCaAppHandler *handler = new(ELeave) CCaAppHandler();
    52     CCaAppHandler *handler = new(ELeave) CCaAppHandler();
    52     CleanupStack::PushL(handler);
    53     CleanupStack::PushL( handler );
    53     handler->ConstructL();
    54     handler->ConstructL();
    54     CleanupStack::Pop(handler);
    55     CleanupStack::Pop( handler );
    55     return handler;
    56     return handler;
    56 }
    57 }
    57 
    58 
    58 // ---------------------------------------------------------
    59 // ---------------------------------------------------------
    59 // CCaAppHandler::CCaAppHandler
    60 // CCaAppHandler::CCaAppHandler
    71 //
    72 //
    72 void CCaAppHandler::ConstructL()
    73 void CCaAppHandler::ConstructL()
    73 {
    74 {
    74 }
    75 }
    75 
    76 
    76 
    77 // ---------------------------------------------------------------------------
    77 // ---------------------------------------------------------------------------
    78 //
    78 //
    79 // ---------------------------------------------------------------------------
    79 // ---------------------------------------------------------------------------
    80 //
    80 //
    81 void CCaAppHandler::HandleCommandL(
    81 void CCaAppHandler::HandleCommandL(CCaInnerEntry &aEntry,
    82         CCaInnerEntry &aEntry, const TDesC8 &aCommand )
    82                                    const TDesC8 &aCommand)
    83 {
    83 {
    84     if( aCommand == KCaCmdOpen()
    84     if (aCommand == KCaCmdOpen() && aEntry.GetEntryTypeName()
    85             && aEntry.GetEntryTypeName() == KCaTypeApp() )
    85             == KCaTypeApp()) {
    86         {
    86         TInt viewId(-1);
    87         TInt viewId(-1);
    87         TBuf<KCaMaxAttrValueLen> viewIdValue;
    88         TBuf<KCaMaxAttrValueLen> viewIdValue;
    88         if (aEntry.FindAttribute(KCaAttrView(), viewIdValue)) {
    89         if( aEntry.FindAttribute( KCaAttrView(), viewIdValue ) )
    89             if (MenuUtils::GetTUint(viewIdValue, (TUint &) viewId)
    90             {
    90                     != KErrNone) {
    91             if( MenuUtils::GetTUint( viewIdValue, (TUint &) viewId )
    91                 User::Leave(KErrCorrupt);
    92                     != KErrNone )
    92             }
    93                 {
    93         }
    94                 User::Leave( KErrCorrupt );
    94         LaunchApplicationL(TUid::Uid(aEntry.GetUid()), KNullDesC8(),
    95                 }
    95                            viewId);
    96             }
    96     } else if (aCommand == KCaCmdClose() && aEntry.GetEntryTypeName()
    97         LaunchApplicationL(
    97                == KCaTypeApp()) {
    98                 TUid::Uid( aEntry.GetUid() ), KNullDesC8(), viewId );
    98         CloseApplicationL(aEntry);
    99         }
    99     } else if (aCommand == KCaCmdRemove()
   100     else if ( aCommand == KCaCmdClose()
   100                && (aEntry.GetEntryTypeName() == KCaTypeApp()
   101             && aEntry.GetEntryTypeName() == KCaTypeApp() )
   101                    || aEntry.GetEntryTypeName() == KCaTypeWidget())) {
   102         {
   102         if (iUninstallOperation && iUninstallOperation->IsActive()) {
   103         CloseApplicationL( aEntry );
   103             User::Leave(KErrInUse);
   104         }
   104         }
   105     else if ( aCommand == KCaCmdRemove()
       
   106                && ( aEntry.GetEntryTypeName() == KCaTypeApp()
       
   107                    || aEntry.GetEntryTypeName() == KCaTypeWidget() ) )
       
   108         {
       
   109         if ( iUninstallOperation && iUninstallOperation->IsActive() )
       
   110             {
       
   111             User::Leave( KErrInUse );
       
   112             }
   105         delete iUninstallOperation;
   113         delete iUninstallOperation;
   106         iUninstallOperation = NULL;
   114         iUninstallOperation = NULL;
   107         iUninstallOperation = CCaUninstallOperation::NewL(aEntry);
   115         iUninstallOperation = CCaUninstallOperation::NewL( aEntry );
   108     } else {
   116         }
   109         User::Leave(KErrNotSupported);
   117     else
   110     }
   118         {
   111 }
   119         User::Leave( KErrNotSupported );
   112 
   120         }
   113 // ---------------------------------------------------------------------------
   121 }
   114 //
   122 
   115 // ---------------------------------------------------------------------------
   123 // ---------------------------------------------------------------------------
   116 //
   124 //
   117 void CCaAppHandler::LaunchApplicationL(const TUid aUid,
   125 // ---------------------------------------------------------------------------
   118                                        const TDesC8 &aParam, TInt aViewId)
   126 //
   119 {
   127 void CCaAppHandler::LaunchApplicationL(
   120     if (aViewId > 0 && iEikEnv) {
   128         const TUid aUid, const TDesC8 &aParam, TInt aViewId )
   121         TUid viewId = TUid::Uid(aViewId);
   129 {
   122         TVwsViewId view(aUid, viewId);
   130     if( aViewId > 0 && iEikEnv )
   123         iEikEnv->EikAppUi()->ActivateViewL(view);
   131         {
   124     } else {
   132         TUid viewId = TUid::Uid( aViewId );
       
   133         TVwsViewId view( aUid, viewId );
       
   134         iEikEnv->EikAppUi()->ActivateViewL( view );
       
   135         }
       
   136     else
       
   137         {
   125         RWsSession wsSession;
   138         RWsSession wsSession;
   126         User::LeaveIfError(wsSession.Connect());
   139         User::LeaveIfError( wsSession.Connect() );
   127         CleanupClosePushL<RWsSession> (wsSession);
   140         CleanupClosePushL<RWsSession>( wsSession );
   128 
   141 
   129         CAknTaskList *taskList = CAknTaskList::NewL(wsSession);
   142         CCaTaskList* taskList = CCaTaskList::NewLC( wsSession );
   130         TApaTask task = taskList->FindRootApp(aUid);
   143         TApaTask task = taskList->FindRootApp( aUid );
   131         delete taskList;
   144         CleanupStack::PopAndDestroy( taskList );
   132 
   145 
   133         if (task.Exists()) {
   146         if( task.Exists() )
       
   147             {
   134             task.BringToForeground();
   148             task.BringToForeground();
   135         } else {
   149             }
       
   150         else
       
   151             {
   136             TApaAppInfo appInfo;
   152             TApaAppInfo appInfo;
   137             TApaAppCapabilityBuf capabilityBuf;
   153             TApaAppCapabilityBuf capabilityBuf;
   138             RApaLsSession appArcSession;
   154             RApaLsSession appArcSession;
   139             User::LeaveIfError(appArcSession.Connect());
   155             User::LeaveIfError( appArcSession.Connect() );
   140             CleanupClosePushL<RApaLsSession> (appArcSession);
   156             CleanupClosePushL<RApaLsSession>( appArcSession );
   141 
   157 
   142             User::LeaveIfError(appArcSession.GetAppInfo(appInfo, aUid));
   158             User::LeaveIfError( appArcSession.GetAppInfo( appInfo, aUid ) );
   143             User::LeaveIfError(appArcSession.GetAppCapability(
   159             User::LeaveIfError( appArcSession.GetAppCapability(
   144                                    capabilityBuf, aUid));
   160                                    capabilityBuf, aUid ) );
   145 
   161 
   146             TApaAppCapability &caps = capabilityBuf();
   162             TApaAppCapability &caps = capabilityBuf();
   147             TFileName appName = appInfo.iFullName;
   163             TFileName appName = appInfo.iFullName;
   148             CApaCommandLine *cmdLine = CApaCommandLine::NewLC();
   164             CApaCommandLine *cmdLine = CApaCommandLine::NewLC();
   149             cmdLine->SetExecutableNameL(appName);
   165             cmdLine->SetExecutableNameL( appName );
   150 
   166 
   151             if (caps.iLaunchInBackground) {
   167             if( caps.iLaunchInBackground )
   152                 cmdLine->SetCommandL(EApaCommandBackground);
   168                 {
   153             } else {
   169                 cmdLine->SetCommandL( EApaCommandBackground );
   154                 cmdLine->SetCommandL(EApaCommandRun);
   170                 }
   155             }
   171             else
   156 
   172                 {
   157             cmdLine->SetTailEndL(aParam);
   173                 cmdLine->SetCommandL( EApaCommandRun );
   158 
   174                 }
   159             User::LeaveIfError(appArcSession.StartApp(*cmdLine));
   175 
   160 
   176             cmdLine->SetTailEndL( aParam );
   161             CleanupStack::PopAndDestroy(cmdLine);
   177 
   162             CleanupStack::PopAndDestroy(&appArcSession);
   178             User::LeaveIfError( appArcSession.StartApp( *cmdLine ) );
   163         }
   179 
   164         CleanupStack::PopAndDestroy(&wsSession);
   180             CleanupStack::PopAndDestroy( cmdLine );
       
   181             CleanupStack::PopAndDestroy( &appArcSession );
       
   182         }
       
   183         CleanupStack::PopAndDestroy( &wsSession );
   165     }
   184     }
   166 }
   185 }
   167 
   186 
   168 // ---------------------------------------------------------------------------
   187 // ---------------------------------------------------------------------------
   169 //
   188 //
   170 // ---------------------------------------------------------------------------
   189 // ---------------------------------------------------------------------------
   171 //
   190 //
   172 void CCaAppHandler::CloseApplicationL(CCaInnerEntry &aEntry)
   191 void CCaAppHandler::CloseApplicationL( CCaInnerEntry &aEntry )
   173 {
   192 {
   174     RWsSession wsSession;
   193     RWsSession wsSession;
   175     User::LeaveIfError(wsSession.Connect());
   194     User::LeaveIfError( wsSession.Connect() );
   176     CleanupClosePushL<RWsSession> (wsSession);
   195     CleanupClosePushL<RWsSession>( wsSession );
   177 
   196 
   178     if ((aEntry.GetFlags() & ERunning) &&
   197     if( ( aEntry.GetFlags() & ERunning )
   179             (!(aEntry.GetFlags() & ESystem))) {
   198             && !( aEntry.GetFlags() & ESystem ) )
       
   199         {
   180         RBuf value;
   200         RBuf value;
   181         CleanupClosePushL(value);
   201         CleanupClosePushL( value );
   182         value.CreateL(KCaMaxAttrValueLen);
   202         value.CreateL( KCaMaxAttrValueLen );
   183         if (aEntry.FindAttribute(KCaAttrWindowGroupId, value)) {
   203         if( aEntry.FindAttribute( KCaAttrWindowGroupId, value ) )
   184             TInt wgId(KErrNotFound);
   204             {
   185             TLex16 parser(value);
   205             TInt wgId( KErrNotFound );
   186             if (KErrNone == parser.Val(wgId) && wgId > 0) {
   206             TLex16 parser( value );
       
   207             if( KErrNone == parser.Val( wgId ) && wgId > 0 )
       
   208                 {
   187                 TWsEvent event;
   209                 TWsEvent event;
   188                 event.SetTimeNow();
   210                 event.SetTimeNow();
   189                 event.SetType(KAknShutOrHideApp);
   211                 event.SetType( KAknShutOrHideApp );
   190                 wsSession.SendEventToWindowGroup(wgId, event);
   212                 wsSession.SendEventToWindowGroup( wgId, event );
   191             }
   213                 }
   192         }
   214             }
   193         CleanupStack::PopAndDestroy(&value);
   215         CleanupStack::PopAndDestroy( &value );
   194     }
   216     }
   195 
   217 
   196     CleanupStack::PopAndDestroy(&wsSession);
   218     CleanupStack::PopAndDestroy( &wsSession );
   197 }
   219 }
   198 
   220