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 #include "tsscreenshotmsg.h"

    22 #include "tsunregscreenshotmsg.h"

    23 #include "tsvisibilitymsg.h"

    24 

    25 TInt RTsSession::Connect()

    26 {

    27     TInt retry = 4;

    28     TInt error(KErrNone);

    29     do {

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

    31         if (KErrNotFound == error || KErrServerTerminated == error) {

    32             error = StartServer();

    33             if (KErrNone == error || KErrAlreadyExists == error) {

    34                 retry = 0;

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

    36             }

    37         } else {

    38             retry = 0;

    39         }

    40     } while (--retry > 0);

    41     return error;

    42 }

    43 

    44 TInt RTsSession::StartServer()

    45 {

    46     TInt error;

    47 

    48     RSemaphore semaphore;

    49     error = semaphore.CreateGlobal(KTsServerReadySemaphore, 0);

    50     

    51     if (KErrNone == error || KErrAlreadyExists == error) {

    52         RProcess server;

    53         error = server.Create(KRunningAppServerName, KNullDesC, TUidType(KNullUid, KNullUid, KRunningAppServerUid));

    54         if (KErrNone == error) {

    55             TRequestStatus status;

    56             server.Rendezvous(status);

    57             

    58             if (status != KRequestPending) {

    59                 server.Kill(0);

    60                 User::WaitForRequest(status);

    61             } else {

    62                 server.Resume();

    63                 User::WaitForRequest(status);

    64 

    65                 // wait for server

    66                 semaphore.Wait();

    67             }

    68 

    69             if (KErrCancel == status.Int()) {

    70                 error = KErrNone;

    71             } else {

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

    73             }

    74         }

    75         server.Close();

    76     }

    77     semaphore.Close();

    78 

    79     return error;

    80 }

    81 

    82 

    83 HBufC8* RTsSession::TasksContentLC()

    84 {

    85     for (;;) {

    86         TPckgBuf<TInt> dataSize;

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

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

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

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

    91         if (err == KErrNone) {

    92             return data;

    93         } else if (err != KErrCorrupt) {

    94             User::Leave(err);

    95         }

    96         CleanupStack::PopAndDestroy(data);

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

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

    99     }

   100 }

   101 

   102 void RTsSession::Subscribe(TRequestStatus& aStatus)

   103 {

   104     SendReceive(SubscribeRunningAppChanges, aStatus);

   105 }

   106 

   107 void RTsSession::CancelSubscribe()

   108 {

   109     SendReceive(CancelSubscribeRunningAppChanges);

   110 }

   111 

   112 void RTsSession::OpenTask(const TDesC8 &key)

   113 {

   114     SendReceive(OpenTaskMessage, TIpcArgs(&key));

   115 }

   116 

   117 void RTsSession::CloseTask(const TDesC8 &key)

   118 {

   119     SendReceive(CloseTaskMessage, TIpcArgs(&key));

   120 }

   121 

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

   123 {

   124    TRAPD(errNo, RegisterScreenshotL(screenshot, wgId, priority));

   125    return errNo;

   126 }

   127 

   128 TInt RTsSession::UnregisterScreenshot(TInt wgId)

   129 {

   130     TRAPD(errNo, UnregisterScreenshotL(wgId));

   131    return errNo;

   132 }

   133 

   134 TInt RTsSession::SetVisibility(TInt wgId, Visibility value)

   135 {

   136     TRAPD(errNo, SetVisibilityL(wgId, value));

   137     return errNo;

   138 }

   139 

   140 void RTsSession::RegisterScreenshotL(CFbsBitmap *screenshot, TInt wgId, UpdatePriority priority)

   141 {

   142     CTsScreenshotMsg *message = CTsScreenshotMsg::NewLC(wgId, *screenshot, priority, 0);

   143     HBufC8* serializedData = message->ExternalizeLC();

   144     TIpcArgs arguments(serializedData);

   145     User::LeaveIfError(SendReceive(RegisterScreenshotMessage, arguments));

   146     CleanupStack::PopAndDestroy(serializedData);

   147     CleanupStack::PopAndDestroy(message);

   148 }

   149 

   150 void RTsSession::UnregisterScreenshotL(TInt wgId)

   151 {

   152     CTsUnregisterScreenshotMsg *message = CTsUnregisterScreenshotMsg::NewLC(wgId);

   153     HBufC8* serializedData = message->ExternalizeLC();

   154     TIpcArgs arguments(serializedData);

   155     User::LeaveIfError(SendReceive(UnregisterScreenshotMessage, arguments));

   156     CleanupStack::PopAndDestroy(serializedData);

   157     CleanupStack::PopAndDestroy(message);

   158 }

   159 

   160 void RTsSession::SetVisibilityL(TInt wgId, Visibility value)

   161 {

   162     CTsVisibilitMsg *message = CTsVisibilitMsg::NewLC(wgId, value);

   163     HBufC8* serializedData = message->ExternalizeLC();

   164     TIpcArgs arguments(serializedData);

   165     User::LeaveIfError(SendReceive(VisibilityChange, arguments));

   166     CleanupStack::PopAndDestroy(serializedData);

   167     CleanupStack::PopAndDestroy(message);

   168 }