src/main/symbian/SDL_main.cpp

   1 extern "C" {
   2 #include "SDL_events_c.h"
   3 }
   4 #include <queue>
   5 #include "epoc_sdl.h"
   6 #include "sdlepocapi.h"
   7 #include <e32base.h>
   8 #include <estlib.h>
   9 #include <stdio.h>
  10 #include <badesca.h>
  11 #include <w32std.h>
  12 #include <aknappui.h>
  13 #include <aknapp.h>
  14 #include "SDL_epocevents_c.h"
  15 #include "SDL_keysym.h"
  16 #include "dsa.h"
  17 #include "SDL_loadso.h"
  18 #include <remconcoreapitargetobserver.h>
  19 #include <remconinterfaceselector.h>
  20 #include <remconcoreapitarget.h>
  21
  22 extern SDLKey* KeyMap();
  23 extern void ResetKeyMap();
  24
  25 class CCurrentAppUi;
  26 class CEikonEnv;
  27 class CSdlAppServ;
  28 class CEventQueue;
  29
  30 NONSHARABLE_CLASS(EpocSdlEnvData)
  31 {
  32         public:
  33                 void Free();
  34                 void Delete();
  35                 CEventQueue*            iEventQueue;
  36                 TMainFunc               iMain;
  37                 int                     iEpocEnvFlags;
  38                 int                     iArgc;
  39                 char**                  iArgv;
  40                 CDsa*                   iDsa;
  41                 CSdlAppServ*            iAppSrv;
  42                 TThreadId               iId;
  43                 CArrayFix<TSdlCleanupItem>* iCleanupItems;
  44                 CSDL*                   iSdl;
  45                 TRequestStatus*         iCallerStatus;
  46                 bool                    iWaitingForOrientationChange;
  47
  48                 TSize                   iSize;
  49                 TDisplayMode            iMode;
  50 };
  51
  52 EpocSdlEnvData* gEpocEnv;
  53
  54 NONSHARABLE_CLASS(EnvUtils)
  55 {
  56         public:
  57                 static inline TBool IsOwnThreaded();
  58                 static TBool Rendezvous(RThread& aThread, TRequestStatus& aStatus);
  59                 static void RunSingleThread();
  60 };
  61
  62 inline TBool EnvUtils::IsOwnThreaded()
  63 {
  64         return gEpocEnv->iEpocEnvFlags & CSDL::EOwnThread;
  65 }
  66
  67 void EnvUtils::RunSingleThread()
  68 {
  69         if(!EnvUtils::IsOwnThreaded())
  70         {
  71                 int count = RThread().RequestCount();
  72                 if(count > 0)
  73                 {
  74                         int err;
  75                         if(CActiveScheduler::RunIfReady(err, CActive::EPriorityIdle))
  76                         {
  77                                 CActiveScheduler::Current()->WaitForAnyRequest();
  78                         }
  79                 }
  80         }
  81 }
  82
  83 int Panic(int aErr, int aLine)
  84 {
  85         TBuf<64> b;
  86         b.Format(_L("Main at %d"), aLine);
  87         User::Panic(b, aErr);
  88         return 0;
  89 }
  90
  91
  92 class CEventQueue : public CBase, public MEventQueue
  93 {
  94         public:
  95                 void ConstructL();
  96                 ~CEventQueue();
  97                 int Append(const TWsEvent& aEvent);
  98                 const TWsEvent Shift();
  99                 void Lock();
 100                 void Unlock();
 101                 TBool HasData();
 102
 103         private:
 104                 std::queue<TWsEvent> m_queue;
 105                 RCriticalSection iCS;
 106 };
 107
 108 void CEventQueue::ConstructL()
 109 {
 110         if(EnvUtils::IsOwnThreaded())
 111                 User::LeaveIfError(iCS.CreateLocal());
 112 }
 113
 114 CEventQueue::~CEventQueue()
 115 {
 116         iCS.Close();
 117 }
 118
 119 int CEventQueue::Append(const TWsEvent& aEvent)
 120 {
 121         Lock();
 122         m_queue.push(aEvent);
 123         Unlock();
 124         return 0;
 125 }
 126
 127
 128 TBool CEventQueue::HasData()
 129 {
 130         EnvUtils::RunSingleThread();
 131         return !m_queue.empty();
 132 }
 133
 134 void CEventQueue::Lock()
 135 {
 136         if(EnvUtils::IsOwnThreaded())
 137                 iCS.Wait();
 138 }
 139
 140 void CEventQueue::Unlock()
 141 {
 142         if(EnvUtils::IsOwnThreaded())
 143                 iCS.Signal();
 144 }
 145
 146 const TWsEvent CEventQueue::Shift()
 147 {
 148         const TWsEvent event = m_queue.front();
 149         m_queue.pop();
 150         return event;
 151 }
 152
 153
 154 TSdlCleanupItem::TSdlCleanupItem(TSdlCleanupOperation aOperation, TAny* aItem) :
 155         iOperation(aOperation), iItem(aItem), iThread(RThread().Id())
 156 {}
 157
 158 #define MAINFUNC(x) EXPORT_C TMainFunc::TMainFunc(mainfunc##x aFunc){Mem::FillZ(iMainFunc, sizeof(iMainFunc)); iMainFunc[x - 1] = (void*) aFunc;}
 159
 160         MAINFUNC(1)
 161         MAINFUNC(2)
 162         MAINFUNC(3)
 163         MAINFUNC(4)
 164         MAINFUNC(5)
 165 MAINFUNC(6)
 166
 167 EXPORT_C TMainFunc::TMainFunc()
 168 {
 169         Mem::FillZ(iMainFunc, sizeof(iMainFunc));
 170 }
 171
 172
 173 const void* TMainFunc::operator[](int aIndex) const
 174 {
 175         return iMainFunc[aIndex];
 176 }
 177
 178
 179 NONSHARABLE_CLASS(CSdlAppServ) : public CActive
 180 {
 181         public:
 182                 enum
 183                 {
 184                         EAppSrvNoop = CDsa::ELastDsaRequest,
 185                         EAppSrvWindowWidth,
 186                         EAppSrvWindowHeight,
 187                         EAppSrvWindowDisplayMode,
 188                         EAppSrvWindowPointerCursorMode,
 189                         EAppSrvDsaStatus,
 190                         EAppSrvStopThread,
 191                         EAppSrvWaitDsa
 192                 };
 193                 CSdlAppServ();
 194                 void ConstructL();
 195                 ~CSdlAppServ();
 196                 int Request(int aService);
 197                 int RequestValue(int aService);
 198                 void Init();
 199                 void PanicMain(int aReason);
 200                 void PanicMain(const TDesC& aInfo, int aReason);
 201                 void SetObserver(MSDLObserver* aObserver);
 202                 int ObserverEvent(int aEvent, int aParam);
 203                 void SetParam(int aParam);
 204                 void HandleObserverValue(int aService, int aReturnValue, TBool aMainThread);
 205                 MSDLObserver* Observer();
 206
 207         private:
 208                 void RunL();
 209                 void DoCancel();
 210                 const TThreadId iMainId;
 211                 RThread iAppThread;
 212                 int iService;
 213                 int iReturnValue;
 214                 RSemaphore iSema;
 215                 MSDLObserver* iObserver;
 216                 TRequestStatus* iStatusPtr;
 217 };
 218
 219 CSdlAppServ::CSdlAppServ() : CActive(CActive::EPriorityHigh), iMainId(RThread().Id()), iObserver( NULL )
 220 {}
 221
 222
 223 MSDLObserver* CSdlAppServ::Observer()
 224 {
 225         return iObserver;
 226 }
 227
 228 void CSdlAppServ::SetObserver(MSDLObserver* aObserver)
 229 {
 230         iObserver = aObserver;
 231 }
 232
 233 int CSdlAppServ::ObserverEvent(int aEvent, int aParam)
 234 {
 235         if(iObserver != NULL)
 236         {
 237                 if(RThread().Id() == gEpocEnv->iId && EnvUtils::IsOwnThreaded())
 238                 {
 239                         return iObserver->SdlThreadEvent(aEvent, aParam);
 240                 }
 241                 else if(RThread().Id() == iMainId)
 242                 {
 243                         return iObserver->SdlEvent(aEvent, aParam);
 244                 }
 245                 PANIC(KErrNotSupported);
 246         }
 247         return 0;
 248 }
 249
 250 void CSdlAppServ::PanicMain(int aReason)
 251 {
 252         iAppThread.Panic(RThread().Name(), aReason);
 253 }
 254
 255 void CSdlAppServ::PanicMain(const TDesC& aInfo, int aReason)
 256 {
 257         iAppThread.Panic(aInfo, aReason);
 258 }
 259
 260 void CSdlAppServ::ConstructL()
 261 {
 262         CActiveScheduler::Add(this);
 263         if(EnvUtils::IsOwnThreaded())
 264                 User::LeaveIfError(iSema.CreateLocal(1));
 265         iStatus = KRequestPending;
 266         iStatusPtr = &iStatus;
 267         SetActive();
 268 }
 269
 270 CSdlAppServ::~CSdlAppServ()
 271 {
 272         Cancel();
 273         if(iSema.Handle() != NULL)
 274                 iSema.Signal();
 275         iSema.Close();
 276         iAppThread.Close();
 277 }
 278
 279 int CSdlAppServ::Request(int aService)
 280 {
 281         if(EnvUtils::IsOwnThreaded())
 282         {
 283                 if(RThread().Id() == iAppThread.Id())
 284                         return KErrBadHandle;
 285                 iSema.Wait();
 286         }
 287         EnvUtils::RunSingleThread();
 288         iService = aService;
 289         iAppThread.RequestComplete(iStatusPtr, KErrNone);
 290         return KErrNone;
 291 }
 292
 293 int CSdlAppServ::RequestValue(int aService)
 294 {
 295         Request(aService);
 296         Request(EAppSrvNoop);
 297         return iReturnValue;
 298 }
 299
 300 void CSdlAppServ::Init()
 301 {
 302         PANIC_IF_ERROR(iAppThread.Open(iMainId));
 303 }
 304
 305 void CSdlAppServ::SetParam(int aParam)
 306 {
 307         iReturnValue = aParam;
 308 }
 309
 310 void CSdlAppServ::HandleObserverValue(int aService, int aReturnValue, TBool aMainThread)
 311 {
 312         if(!aMainThread && aService == MSDLObserver::EEventSuspend)
 313         {
 314                 if(iObserver == NULL || (gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->Stopped() && aReturnValue != MSDLObserver::ESuspendNoSuspend))
 315                 {
 316                         EpocSdlEnv::Suspend();
 317                 }
 318         }
 319 }
 320
 321 void CSdlAppServ::RunL()
 322 {
 323         if(iStatus == KErrNone)
 324         {
 325                 switch(iService)
 326                 {
 327                         case CSdlAppServ::EAppSrvWaitDsa:
 328                                 EpocSdlEnv::SetWaitDsa();
 329                                 iReturnValue = EpocSdlEnv::IsDsaAvailable();
 330                                 break;
 331
 332                         case CSdlAppServ::EAppSrvStopThread:
 333                                 if(gEpocEnv->iDsa != NULL)
 334                                         gEpocEnv->iDsa->SetSuspend();
 335                                 break;
 336
 337                         case EAppSrvWindowPointerCursorMode:
 338                                 iReturnValue = gEpocEnv->iDsa != NULL ? gEpocEnv->iDsa->Session().PointerCursorMode() : KErrNotReady;
 339                                 break;
 340
 341                         case EAppSrvDsaStatus:
 342                                 if(gEpocEnv->iDsa != NULL)
 343                                         gEpocEnv->iDsa->Stop();
 344                                 iReturnValue = KErrNone;
 345                                 break;
 346
 347                         case EAppSrvNoop:
 348                                 break;
 349
 350                         case MSDLObserver::EEventResume:
 351                         case MSDLObserver::EEventSuspend:
 352                         case MSDLObserver::EEventWindowReserved:
 353                         case MSDLObserver::EEventKeyMapInit:
 354                         case MSDLObserver::EEventWindowNotAvailable:
 355                         case MSDLObserver::EEventMainExit:
 356                                 iReturnValue = ObserverEvent(iService, iReturnValue);
 357                                 HandleObserverValue(iService, iReturnValue, ETrue);
 358                                 break;
 359
 360                         default:
 361                                 PANIC(KErrNotSupported);
 362                                 break;
 363                 }
 364
 365                 iStatus = KRequestPending;
 366                 iStatusPtr = &iStatus;
 367                 SetActive();
 368         }
 369
 370         if(EnvUtils::IsOwnThreaded())
 371                 iSema.Signal();
 372 }
 373
 374 void CSdlAppServ::DoCancel()
 375 {
 376         if(EnvUtils::IsOwnThreaded())
 377                 iSema.Wait();
 378         TRequestStatus* s = &iStatus;
 379         iAppThread.RequestComplete(s, KErrCancel);
 380 }
 381
 382 MEventQueue& EpocSdlEnv::EventQueue()
 383 {
 384         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 385         return *gEpocEnv->iEventQueue;
 386 }
 387
 388
 389 TBool EpocSdlEnv::Flags(int aFlag)
 390 {
 391         const int flag = gEpocEnv->iEpocEnvFlags & aFlag;
 392         return flag == aFlag;
 393 }
 394
 395 int EpocSdlEnv::Argc()
 396 {
 397         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 398         return gEpocEnv->iArgc;
 399 }
 400
 401 char** EpocSdlEnv::Argv()
 402 {
 403         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 404         return gEpocEnv->iArgv;
 405 }
 406
 407 TBool EpocSdlEnv::IsDsaAvailable()
 408 {
 409         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 410         return gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->IsDsaAvailable();
 411 }
 412
 413 void EpocSdlEnv::WaitDsaAvailable()
 414 {
 415         EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowNotAvailable, 0);
 416         gEpocEnv->iAppSrv->Request(CSdlAppServ::EAppSrvStopThread);
 417         if(EpocSdlEnv::Flags(CSDL::EEnableFocusStop))
 418         {
 419                 EpocSdlEnv::ObserverEvent(MSDLObserver::EEventSuspend, 0);
 420         }
 421 }
 422
 423 void EpocSdlEnv::Suspend()
 424 {
 425         if(gEpocEnv->iDsa != NULL && (gEpocEnv->iDsa->Stopped() || EpocSdlEnv::Flags(CSDL::EEnableFocusStop)))
 426         {
 427                 gEpocEnv->iDsa->SetSuspend();
 428                 if(EnvUtils::IsOwnThreaded())
 429                 {
 430                         RThread().Suspend();
 431                         EpocSdlEnv::ObserverEvent(MSDLObserver::EEventResume, 0);
 432                 }
 433         }
 434 }
 435
 436 void EpocSdlEnv::SetWaitDsa()
 437 {
 438         if(!IsDsaAvailable())
 439         {
 440                 if(EnvUtils::IsOwnThreaded())
 441                 {
 442                         RThread th;
 443                         th.Open(gEpocEnv->iId);
 444                         th.Suspend();
 445                         th.Close();
 446                 }
 447                 if(gEpocEnv->iDsa != NULL)
 448                         gEpocEnv->iDsa->SetSuspend();
 449         }
 450 }
 451
 452 void EpocSdlEnv::Resume()
 453 {
 454         if(gEpocEnv->iDsa != NULL)
 455         {
 456                 gEpocEnv->iDsa->Resume();
 457         }
 458         if(EnvUtils::IsOwnThreaded())
 459         {
 460                 RThread th;
 461                 th.Open(gEpocEnv->iId);
 462                 th.Resume();
 463                 th.Close();
 464         }
 465         const int value = gEpocEnv->iAppSrv->ObserverEvent(MSDLObserver::EEventResume, 0);
 466         gEpocEnv->iAppSrv->HandleObserverValue(MSDLObserver::EEventResume, value, ETrue);
 467 }
 468
 469 int EpocSdlEnv::AllocSurface(const TSize& aSize, TDisplayMode aMode)
 470 {
 471         return gEpocEnv->iDsa->AllocSurface(aSize, aMode);
 472 }
 473
 474 void EpocSdlEnv::UnlockHwSurface()
 475 {
 476         gEpocEnv->iDsa->UnlockHwSurface();
 477 }
 478
 479 TUint8* EpocSdlEnv::LockHwSurface()
 480 {
 481         return gEpocEnv->iDsa->LockHwSurface();
 482 }
 483
 484 void EpocSdlEnv::UpdateSwSurface()
 485 {
 486         gEpocEnv->iDsa->UpdateSwSurface();
 487 }
 488
 489 TBool EpocSdlEnv::AddUpdateRect(TUint8* aAddress, const TRect& aUpdateRect, const TRect& aRect)
 490 {
 491         return gEpocEnv->iDsa->AddUpdateRect(aAddress, aUpdateRect, aRect);
 492 }
 493
 494 void EpocSdlEnv::Request(int aService)
 495 {
 496         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 497         gEpocEnv->iAppSrv->Request(aService);
 498 }
 499
 500 TDisplayMode EpocSdlEnv::DisplayMode()
 501 {
 502         return gEpocEnv->iDsa == NULL ? ENone : gEpocEnv->iDsa->DisplayMode();
 503 }
 504
 505 TPointerCursorMode EpocSdlEnv::PointerMode()
 506 {
 507         return static_cast<TPointerCursorMode>(gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWindowPointerCursorMode));
 508 }
 509
 510 int EpocSdlEnv::SetPalette(int aFirstcolor, int aColorCount, TUint32* aPalette)
 511 {
 512         return  gEpocEnv->iDsa->SetPalette(aFirstcolor, aColorCount, aPalette);
 513 }
 514
 515 void EpocSdlEnv::PanicMain(int aErr)
 516 {
 517         gEpocEnv->iAppSrv->PanicMain(aErr);
 518 }
 519
 520
 521 int EpocSdlEnv::AppendCleanupItem(const TSdlCleanupItem& aItem)
 522 {
 523         TRAPD(err, gEpocEnv->iCleanupItems->AppendL(aItem));
 524         return err;
 525 }
 526
 527 void EpocSdlEnv::RemoveCleanupItem(TAny* aItem)
 528 {
 529         for(int i = 0; i < gEpocEnv->iCleanupItems->Count(); i++)
 530         {
 531                 if(gEpocEnv->iCleanupItems->At(i).iItem == aItem)
 532                         gEpocEnv->iCleanupItems->Delete(i);
 533         }
 534 }
 535
 536 void EpocSdlEnv::CleanupItems()
 537 {
 538         const TThreadId id = RThread().Id();
 539         int last = gEpocEnv->iCleanupItems->Count() - 1;
 540         int i;
 541
 542         for(i = last; i >= 0 ; i--)
 543         {
 544                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 545                 if(item.iThread == id)
 546                 {
 547                         item.iThread = TThreadId(0);
 548                         item.iOperation(item.iItem);
 549                 }
 550         }
 551
 552         last = gEpocEnv->iCleanupItems->Count() - 1;
 553
 554         for(i = last; i >= 0 ; i--)
 555         {
 556                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 557                 if(item.iThread == TThreadId(0))
 558                 {
 559                         gEpocEnv->iCleanupItems->Delete(i);
 560                 }
 561         }
 562 }
 563
 564 void EpocSdlEnv::FreeSurface()
 565 {
 566         Request(CSdlAppServ::EAppSrvDsaStatus);
 567         if(gEpocEnv->iDsa != NULL)
 568                 gEpocEnv->iDsa->Free();
 569 }
 570
 571 void EpocSdlEnv::ObserverEvent(int aService, int aParam)
 572 {
 573         const TBool sdlThread = RThread().Id() == gEpocEnv->iId;
 574         const int valuea = gEpocEnv->iAppSrv->ObserverEvent(aService, aParam);
 575         gEpocEnv->iAppSrv->HandleObserverValue(aService, valuea, !sdlThread);
 576         if(sdlThread)
 577         {
 578                 gEpocEnv->iAppSrv->SetParam(aParam);
 579                 const int valuet = gEpocEnv->iAppSrv->RequestValue(aService);
 580                 gEpocEnv->iAppSrv->HandleObserverValue(aService, valuet, EFalse);
 581         }
 582 }
 583
 584 void EpocSdlEnv::PanicMain(const TDesC& aInfo, int aErr)
 585 {
 586         gEpocEnv->iAppSrv->PanicMain(aInfo, aErr);
 587 }
 588
 589 //Dsa is a low priority ao, it has to wait if its pending event, but ws
 590 //event has been prioritized before it
 591 //this is not called from app thread!
 592 void EpocSdlEnv::WaitDeviceChange()
 593 {
 594         gEpocEnv->iAppSrv->RequestValue(CSdlAppServ::EAppSrvWaitDsa);
 595 }
 596
 597 LOCAL_C TBool CheckSdl()
 598 {
 599         int isExit = ETrue;
 600         RThread sdl;
 601         if(sdl.Open(gEpocEnv->iId) == KErrNone)
 602         {
 603                 if(sdl.ExitType() == EExitPending)
 604                 {
 605                         isExit = EFalse;
 606                 }
 607                 sdl.Close();
 608         }
 609         return isExit;
 610 }
 611
 612 void EpocSdlEnvData::Free()
 613 {
 614         if(RThread().Id() == gEpocEnv->iId)
 615         {
 616                 if(iDsa != NULL)
 617                         iDsa->Free();
 618                 return;
 619         }
 620
 621         __ASSERT_ALWAYS(iArgv == NULL || CheckSdl(), PANIC(KErrNotReady));
 622 }
 623
 624 void EpocSdlEnvData::Delete()
 625 {
 626         for(int i = 0; i <= iArgc; i++)
 627         {
 628                 if(iArgv != NULL)
 629                         delete[] iArgv[i];
 630         }
 631
 632         delete[] iArgv;
 633
 634         iArgv = NULL;
 635         iArgc = 0;
 636
 637         delete iEventQueue;
 638
 639         if(iDsa != NULL)
 640                 iDsa->Free();
 641
 642         delete iDsa;
 643         delete iAppSrv;
 644 }
 645
 646 _LIT(KSDLMain, "SDLMain");
 647
 648 LOCAL_C int MainL()
 649 {
 650         gEpocEnv->iCleanupItems = new (ELeave) CArrayFixFlat<TSdlCleanupItem>(8);
 651
 652         char** envp=0;
 653         /* !! process exits here if there is "exit()" in main! */
 654         int ret = 0;
 655         for(int i = 0; i < 6; i++)
 656         {
 657                 void* f = (void*) gEpocEnv->iMain[i];
 658                 if(f != NULL)
 659                 {
 660                         switch(i)
 661                         {
 662                                 case 0:
 663                                         ret = ((mainfunc1)f)();
 664                                         return ret;
 665
 666                                 case 3:
 667                                         ((mainfunc1)f)();
 668                                         return ret;
 669
 670                                 case 1:
 671                                         ret = ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());
 672                                         return ret;
 673
 674                                 case 4:
 675                                         ((mainfunc2)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv());
 676                                         return ret;
 677
 678                                 case 2:
 679                                         ret = ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);
 680                                         return ret;
 681
 682                                 case 5:
 683                                         ((mainfunc3)f)(EpocSdlEnv::Argc(), EpocSdlEnv::Argv(), envp);
 684                                         return ret;
 685                         }
 686                 }
 687         }
 688         PANIC(KErrNotFound);
 689         return 0;
 690 }
 691
 692 LOCAL_C int DoMain(TAny* /*aParam*/)
 693 {
 694         TBool fbsconnected = EFalse;
 695         CTrapCleanup* cleanup = NULL;
 696
 697         if(EnvUtils::IsOwnThreaded())
 698         {
 699                 cleanup = CTrapCleanup::New();
 700
 701                 if(RFbsSession::GetSession() == NULL)
 702                 {
 703                         PANIC_IF_ERROR(RFbsSession::Connect());
 704                         fbsconnected = ETrue;
 705                 }
 706         }
 707         gEpocEnv->iAppSrv->Init();
 708
 709         // Call stdlib main
 710         int ret = 0;
 711         if(EnvUtils::IsOwnThreaded())
 712         {
 713                 //completes waiting rendesvous
 714                 RThread::Rendezvous(KErrNone);
 715         }
 716
 717         TRAPD(err, err = MainL());
 718
 719         EpocSdlEnv::ObserverEvent(MSDLObserver::EEventMainExit, err);
 720
 721         // Free resources and return
 722         EpocSdlEnv::CleanupItems();
 723
 724         gEpocEnv->iCleanupItems->Reset();
 725         delete gEpocEnv->iCleanupItems;
 726         gEpocEnv->iCleanupItems = NULL;
 727
 728         gEpocEnv->Free(); //free up in thread resources
 729
 730         if(fbsconnected)
 731                 RFbsSession::Disconnect();
 732
 733         delete cleanup;
 734
 735         if(gEpocEnv->iCallerStatus != NULL)
 736         {
 737                 User::RequestComplete(gEpocEnv->iCallerStatus, err);
 738                 return 0;
 739         }
 740         else
 741         {
 742                 return err == KErrNone ? ret : err;
 743         }
 744 }
 745
 746 EXPORT_C CSDL::~CSDL()
 747 {
 748         gEpocEnv->Free();
 749         gEpocEnv->Delete();
 750
 751         delete gEpocEnv;
 752         gEpocEnv = NULL;
 753 }
 754
 755 EXPORT_C CSDL* CSDL::NewL(int aFlags)
 756 {
 757         __ASSERT_ALWAYS(gEpocEnv == NULL, PANIC(KErrAlreadyExists));
 758         gEpocEnv = new EpocSdlEnvData;
 759         Mem::FillZ(gEpocEnv, sizeof(EpocSdlEnvData));
 760
 761         gEpocEnv->iEpocEnvFlags = aFlags;
 762         gEpocEnv->iEventQueue = new (ELeave) CEventQueue();
 763         gEpocEnv->iAppSrv = new (ELeave) CSdlAppServ();
 764
 765         CSDL* sdl = new (ELeave) CSDL();
 766
 767         gEpocEnv->iSdl = sdl;
 768
 769         return sdl;
 770 }
 771
 772 EXPORT_C void CSDL::SetContainerWindowL(RWindow& aWindow, RWsSession& aSession, CWsScreenDevice& aDevice)
 773 {
 774         if(gEpocEnv->iDsa == NULL)
 775                 gEpocEnv->iDsa = CDsa::CreateL(aSession);
 776         gEpocEnv->iDsa->ConstructL(aWindow, aDevice);
 777 }
 778
 779 int EpocSdlEnv::ApplyGlesDsa()
 780 {
 781         CDsa* dsa = NULL;
 782         TRAPD(err, dsa = gEpocEnv->iDsa->CreateGlesDsaL());
 783         gEpocEnv->iDsa = dsa;
 784         return err;
 785 }
 786
 787 RWindow* EpocSdlEnv::Window()
 788 {
 789         return gEpocEnv->iDsa->Window();
 790 }
 791
 792 void EpocSdlEnv::UpdateWholeScreen(bool val)
 793 {
 794         gEpocEnv->iDsa->m_updateWholeScreen = val;
 795 }
 796
 797 bool EpocSdlEnv::GetUpdateWholeScreen()
 798 {
 799         return gEpocEnv->iDsa->m_updateWholeScreen;
 800 }
 801
 802 void EpocSdlEnv::SetOrientation(CAknAppUi::TAppUiOrientation orientation, const TSize& aSize, TDisplayMode aMode)
 803 {
 804         gEpocEnv->iWaitingForOrientationChange = true;
 805         gEpocEnv->iSize = aSize;
 806         gEpocEnv->iMode = aMode;
 807
 808         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(orientation));
 809 }
 810
 811 EXPORT_C TThreadId CSDL::CallMainL(const TMainFunc& aFunc, TRequestStatus* const aStatus, const CDesC8Array* const aArg, int aStackSize)
 812 {
 813         ASSERT(gEpocEnv != NULL);
 814         gEpocEnv->iMain = aFunc;
 815         const TBool args = aArg != NULL;
 816
 817         if(gEpocEnv->iArgv != NULL)
 818                 User::Leave(KErrAlreadyExists);
 819
 820         gEpocEnv->iArgc = args ? aArg->Count() + 1 : 0;
 821         gEpocEnv->iArgv = new char*[gEpocEnv->iArgc + 2];
 822
 823         int k = 0;
 824         const TFileName processName = RProcess().FileName();
 825         const int len = processName.Length();
 826         gEpocEnv->iArgv[k] = new char[len + 1];
 827         Mem::Copy(gEpocEnv->iArgv[k], processName.Ptr(), len);
 828         gEpocEnv->iArgv[k][len] = 0;
 829
 830         for(int i = 0; args && (i < aArg->Count()); i++)
 831         {
 832                 k++;
 833                 const int len = aArg->MdcaPoint(i).Length();
 834                 gEpocEnv->iArgv[k] = new char[len + 1];
 835                 Mem::Copy(gEpocEnv->iArgv[k], aArg->MdcaPoint(i).Ptr(), len);
 836                 gEpocEnv->iArgv[k][len] = 0;
 837         }
 838
 839         gEpocEnv->iArgv[k + 1] = NULL;
 840
 841         gEpocEnv->iEventQueue->ConstructL();
 842         gEpocEnv->iAppSrv->ConstructL();
 843
 844         // for handling volume up/down keys
 845         CRemConInterfaceSelector *iSelector = CRemConInterfaceSelector::NewL();
 846         CRemConCoreApiTarget::NewL( *iSelector, *this );
 847         iSelector->OpenTargetL();
 848
 849         if(EnvUtils::IsOwnThreaded())
 850         {
 851                 RThread thread;
 852                 User::LeaveIfError(thread.Create(KSDLMain, DoMain, aStackSize, NULL, NULL));
 853
 854                 if(aStatus != NULL)
 855                 {
 856                         thread.Logon(*aStatus);
 857                 }
 858
 859                 gEpocEnv->iId = thread.Id();
 860                 thread.SetPriority(EPriorityLess);
 861                 thread.Resume();
 862                 thread.Close();
 863         }
 864         else
 865         {
 866                 gEpocEnv->iCallerStatus = aStatus;
 867                 if(aStatus != NULL)
 868                         *aStatus = KRequestPending;
 869                 gEpocEnv->iId = RThread().Id();
 870                 // when priority is not lowered screen updates much more frequently, which
 871                 // may be undesired, for example in case of openttd's generating world dialog
 872                 RThread().SetPriority(EPriorityLess);
 873                 DoMain( NULL );
 874         }
 875
 876         return gEpocEnv->iId;
 877 }
 878
 879 EXPORT_C int CSDL::AppendWsEvent(const TWsEvent& aEvent)
 880 {
 881         return EpocSdlEnv::EventQueue().Append(aEvent);
 882 }
 883
 884 EXPORT_C void CSDL::SDLPanic(const TDesC& aInfo, int aErr)
 885 {
 886         EpocSdlEnv::PanicMain(aInfo, aErr);
 887 }
 888
 889 EXPORT_C int CSDL::GetSDLCode(int aScanCode)
 890 {
 891         if(aScanCode < 0)
 892                 return MAX_SCANCODE;
 893         if(aScanCode >= MAX_SCANCODE)
 894                 return -1;
 895         return KeyMap()[aScanCode];
 896 }
 897
 898 EXPORT_C int CSDL::SDLCodesCount() const
 899 {
 900         return MAX_SCANCODE;
 901 }
 902
 903 EXPORT_C void CSDL::ResetSDLCodes()
 904 {
 905         ResetKeyMap();
 906 }
 907
 908 EXPORT_C int CSDL::SetSDLCode(int aScanCode, int aSDLCode)
 909 {
 910         const int current = GetSDLCode(aScanCode);
 911         if(aScanCode >= 0 && aScanCode < MAX_SCANCODE)
 912                 KeyMap()[aScanCode] = static_cast<SDLKey>(aSDLCode);
 913         return current;
 914 }
 915
 916
 917 EXPORT_C MSDLObserver* CSDL::Observer()
 918 {
 919         return gEpocEnv->iAppSrv->Observer();
 920 }
 921
 922 EXPORT_C void CSDL::SetObserver(MSDLObserver* aObserver)
 923 {
 924         gEpocEnv->iAppSrv->SetObserver(aObserver);
 925 }
 926
 927 EXPORT_C void CSDL::Resume()
 928 {
 929         EpocSdlEnv::Resume();
 930 }
 931
 932 EXPORT_C void CSDL::Suspend()
 933 {
 934         if(gEpocEnv->iDsa != NULL)
 935                 gEpocEnv->iDsa->DoStop();
 936 }
 937
 938 EXPORT_C void CSDL::Resize()
 939 {
 940         if(gEpocEnv->iWaitingForOrientationChange)
 941         {
 942                 EpocSdlEnv::AllocSurface(gEpocEnv->iSize, gEpocEnv->iMode);
 943                 gEpocEnv->iWaitingForOrientationChange = false;
 944         }
 945         else
 946         {
 947                 TSize size = gEpocEnv->iDsa->Window()->Size();
 948                 SDL_PrivateResize(size.iWidth, size.iHeight);
 949         }
 950 }
 951
 952 EXPORT_C CSDL::CSDL()
 953 {}
 954
 955 void CSDL::MrccatoCommand(TRemConCoreApiOperationId aOperationId, TRemConCoreApiButtonAction aButtonAct)
 956 {
 957         if(aButtonAct != ERemConCoreApiButtonClick)
 958                 return;
 959
 960         TWsEvent event;
 961         event.SetType(EEventKey);
 962         event.SetTimeNow();
 963
 964         switch(aOperationId)
 965         {
 966         case ERemConCoreApiVolumeDown:
 967                 event.Key()->iScanCode = EStdKeyDecVolume;
 968                 event.SetType(EEventKeyDown);
 969                 AppendWsEvent(event);
 970                 event.SetType(EEventKeyUp);
 971                 AppendWsEvent(event);
 972                 break;
 973
 974         case ERemConCoreApiVolumeUp:
 975                 event.Key()->iScanCode = EStdKeyIncVolume;
 976                 event.SetType(EEventKeyDown);
 977                 AppendWsEvent(event);
 978                 event.SetType(EEventKeyUp);
 979                 AppendWsEvent(event);
 980                 break;
 981
 982         default:
 983                 break;
 984         }
 985 }
 986
 987 TBool EnvUtils::Rendezvous(RThread& aThread, TRequestStatus& aStatus)
 988 {
 989         if(gEpocEnv->iId != TThreadId(0) &&
 990                         aThread.Open(gEpocEnv->iId) &&
 991                         aThread.ExitType() == EExitPending)
 992         {
 993                 aThread.Rendezvous(aStatus);
 994                 return ETrue;
 995         }
 996         return EFalse;
 997 }
 998
 999 void* SDL_LoadObject(const char *sofile)
1000 {
1001         RLibrary* lib = new RLibrary();
1002         if(lib == NULL)
1003                 return NULL;
1004         TFileName name;
1005         name.Copy(TPtrC8((const TUint8*)sofile));
1006         if(KErrNone == lib->Load(name))
1007                 return lib;
1008         delete lib;
1009         return NULL;
1010 }
1011
1012 void* SDL_LoadFunction(void *handle, const char *name)
1013 {
1014         TLex8 v((const TUint8*)(name));
1015         int ord;
1016
1017         if(KErrNone != v.Val(ord))
1018                 return NULL;
1019
1020         const RLibrary* lib = reinterpret_cast<RLibrary*>(handle);
1021         TLibraryFunction f = lib->Lookup(ord);
1022         return (void*)(f);
1023 }
1024
1025 void SDL_UnloadObject(void *handle)
1026 {
1027         RLibrary* lib = reinterpret_cast<RLibrary*>(handle);
1028         lib->Close();
1029         delete lib;
1030 }