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:

    15 *

    16 */

    17 #include <s32mem.h>

    18 #include <fbs.h>

    19 

    20 #include "tssession.h"

    21 

    22 TInt RTsSession::Connect()

    23 {

    24     TInt retry = 4;

    25     TInt error(KErrNone);

    26     do {

    27         error = CreateSession(KRunningAppServerName, TVersion(0, 0, 0));

    28         if (KErrNotFound != error && KErrServerTerminated != error) {

    29             retry = 0;

    30         } else {

    31             error = StartServer();

    32             if (KErrNone != error && KErrAlreadyExists != error) {

    33                 retry = 0;

    34                 error = CreateSession(KRunningAppServerName, TVersion(0, 0, 0));

    35             }

    36         }

    37     } while (--retry > 0);

    38     return error;

    39 }

    40 

    41 TInt RTsSession::StartServer()

    42 {

    43     RProcess server;

    44     if (TInt error = server.Create(KRunningAppServerName, KNullDesC, TUidType(KNullUid, KNullUid, KRunningAppServerUid))) {

    45         return error;

    46     }

    47 

    48     TRequestStatus status;

    49     server.Rendezvous(status);

    50     if (status != KRequestPending) {

    51         server.Kill(0);

    52     } else {

    53         server.Resume();

    54     }

    55 

    56     User::WaitForRequest(status);

    57     TInt error = (EExitPanic == server.ExitType()) ? KErrGeneral : status.Int();

    58     if (KErrCancel == error) {

    59         error = KErrNone;

    60     }

    61     server.Close();

    62 

    63     return error;

    64 }

    65 

    66 void RTsSession::TaskListL(RTsFswArray& tasks)

    67 {

    68     for (;;) {

    69         TPckgBuf<TInt> dataSize;

    70         User::LeaveIfError(SendReceive(GetRunningAppInfo, TIpcArgs(&dataSize)));

    71         HBufC8* data = HBufC8::NewLC(dataSize());

    72         TPtr8 dataPointer(data->Des());

    73         TInt err = SendReceive(FlushData, TIpcArgs(&dataPointer, dataSize()));

    74         if (err == KErrNone) {

    75             RDesReadStream dataStream(dataPointer);

    76             CleanupClosePushL(dataStream);

    77             CTsFswEntry::InternalizeArrayL(dataStream, tasks);

    78             CleanupStack::PopAndDestroy(&dataStream);

    79         } else if (err != KErrCorrupt) {

    80             User::Leave(err);

    81         }

    82         CleanupStack::PopAndDestroy(data);

    83         if (err == KErrNone) {

    84             break;

    85         }

    86         // If result was KErrCorrupt then the size received from GetRunningAppInfo is

    87         // not valid anymore so restart the whole procedure.

    88     }

    89 }

    90 

    91 void RTsSession::Subscribe(TRequestStatus& aStatus)

    92 {

    93     SendReceive(SubscribeRunningAppChanges, aStatus);

    94 }

    95 

    96 void RTsSession::CancelSubscribe()

    97 {

    98     SendReceive(CancelSubscribeRunningAppChanges);

    99 }

   100 

   101 TInt RTsSession::RegisterScreenshot(CFbsBitmap *screenshot, TInt wgId, UpdatePriority priority)

   102 {

   103     TPckgBuf<TInt> screenshotPackage(screenshot->Handle());

   104     TPckgBuf<TInt> wgIdPackage(wgId);

   105     TPckgBuf<TInt> priorityPackage(priority);

   106 

   107     TIpcArgs arguments;

   108     arguments.Set(ScreenshotHandle, &screenshotPackage);

   109     arguments.Set(WindowsGroup, &wgIdPackage);

   110     arguments.Set(AdditionalParameters, &KNullDesC8);

   111     arguments.Set(Priority, &priorityPackage);

   112 

   113     return SendReceive(RegisterScreenshotMessage, arguments);

   114 }

   115 

   116 void RTsSession::RegisterScreenshot(TRequestStatus &status, CFbsBitmap *screenshot, TInt wgId, UpdatePriority priority)

   117 {

   118     TPckgBuf<TInt> screenshotPackage(screenshot->Handle());

   119     TPckgBuf<TInt> wgIdPackage(wgId);

   120     TPckgBuf<TInt> priorityPackage(priority);

   121 

   122     TIpcArgs arguments;

   123     arguments.Set(ScreenshotHandle, &screenshotPackage);

   124     arguments.Set(WindowsGroup, &wgIdPackage);

   125     arguments.Set(AdditionalParameters, &KNullDesC8);

   126     arguments.Set(Priority, &priorityPackage);

   127 

   128     SendReceive(RegisterScreenshotMessage, arguments, status);

   129 }

   130 

   131 TInt RTsSession::UnregisterScreenshot(TInt wgId)

   132 {

   133     TPckgBuf<TInt> wgIdPackage(wgId);

   134     

   135     TIpcArgs arguments;

   136     arguments.Set(WindowsGroup, &wgIdPackage);

   137     arguments.Set(AdditionalParameters, &KNullDesC8);

   138     

   139     return SendReceive(UnregisterScreenshotMessage, arguments);

   140 }