src/main/symbian/SDL_main.cpp

   1 extern "C" {
   2 #include "SDL_events_c.h"
   3 }
   4 #include "epoc_sdl.h"
   5 #include "sdlepocapi.h"
   6 #include <e32base.h>
   7 #include <estlib.h>
   8 #include <stdio.h>
   9 #include <badesca.h>
  10 #include <w32std.h>
  11 #include <aknappui.h>
  12 #include <aknapp.h>
  13 #include "SDL_epocevents_c.h"
  14 #include "SDL_keysym.h"
  15 #include "dsa.h"
  16 #include "SDL_loadso.h"
  17 #include <remconcoreapitargetobserver.h>
  18 #include <remconinterfaceselector.h>
  19 #include <remconcoreapitarget.h>
  20
  21 class CCurrentAppUi;
  22 class CEikonEnv;
  23 class CSdlAppServ;
  24 class CEventQueue;
  25
  26 class EpocSdlEnvData
  27 {
  28         public:
  29                 void Free();
  30                 void Delete();
  31                 CEventQueue*            iEventQueue;
  32                 CDsa*                   iDsa;
  33                 CSdlAppServ*            iAppSrv;
  34                 TThreadId               iId;
  35                 CArrayFix<TSdlCleanupItem>* iCleanupItems;
  36                 CSDL*                   iSdl;
  37                 bool                    iWaitingForOrientationChange;
  38
  39                 TSize                   iSize;
  40                 TDisplayMode            iMode;
  41 };
  42
  43 EpocSdlEnvData* gEpocEnv;
  44
  45 static void RunSingleThread()
  46 {
  47         if(RThread().RequestCount() > 0)
  48         {
  49                 int err;
  50                 if(CActiveScheduler::RunIfReady(err, CActive::EPriorityIdle))
  51                 {
  52                         CActiveScheduler::Current()->WaitForAnyRequest();
  53                 }
  54         }
  55 }
  56
  57 int Panic(int aErr, int aLine)
  58 {
  59         TBuf<64> b;
  60         b.Format(_L("Main at %d"), aLine);
  61         User::Panic(b, aErr);
  62         return 0;
  63 }
  64
  65
  66 bool CEventQueue::HasData()
  67 {
  68         RunSingleThread();
  69         return !m_queue.empty();
  70 }
  71
  72 const TWsEvent CEventQueue::Shift()
  73 {
  74         const TWsEvent event = m_queue.front();
  75         m_queue.pop();
  76         return event;
  77 }
  78
  79
  80 TSdlCleanupItem::TSdlCleanupItem(TSdlCleanupOperation aOperation, void* aItem) :
  81         iOperation(aOperation), iItem(aItem), iThread(RThread().Id())
  82 {}
  83
  84 #define MAINFUNC(x) TMainFunc::TMainFunc(mainfunc##x aFunc){Mem::FillZ(iMainFunc, sizeof(iMainFunc)); iMainFunc[x - 1] = (void*) aFunc;}
  85
  86 MAINFUNC(1)
  87 MAINFUNC(2)
  88 MAINFUNC(3)
  89 MAINFUNC(4)
  90 MAINFUNC(5)
  91 MAINFUNC(6)
  92
  93 TMainFunc::TMainFunc()
  94 {
  95         Mem::FillZ(iMainFunc, sizeof(iMainFunc));
  96 }
  97
  98 const void* TMainFunc::operator[](int aIndex) const
  99 {
 100         return iMainFunc[aIndex];
 101 }
 102
 103 class CSdlAppServ : public CActive
 104 {
 105         public:
 106                 enum
 107                 {
 108                         EAppSrvDsaStatus,
 109                         EAppSrvStopThread
 110                 };
 111                 CSdlAppServ();
 112                 void ConstructL();
 113                 ~CSdlAppServ();
 114                 int Request(int aService);
 115                 void Init();
 116                 void SetParam(int aParam);
 117
 118         private:
 119                 void RunL();
 120                 void DoCancel();
 121                 const TThreadId iMainId;
 122                 RThread iAppThread;
 123                 int iService;
 124                 int iReturnValue;
 125                 TRequestStatus* iStatusPtr;
 126 };
 127
 128 CSdlAppServ::CSdlAppServ() : CActive(CActive::EPriorityHigh), iMainId(RThread().Id())
 129 {}
 130
 131 void CSdlAppServ::ConstructL()
 132 {
 133         CActiveScheduler::Add(this);
 134         iStatus = KRequestPending;
 135         iStatusPtr = &iStatus;
 136         SetActive();
 137 }
 138
 139 CSdlAppServ::~CSdlAppServ()
 140 {
 141         Cancel();
 142         iAppThread.Close();
 143 }
 144
 145 int CSdlAppServ::Request(int aService)
 146 {
 147         RunSingleThread();
 148         iService = aService;
 149         iAppThread.RequestComplete(iStatusPtr, KErrNone);
 150         return KErrNone;
 151 }
 152
 153 void CSdlAppServ::Init()
 154 {
 155         PANIC_IF_ERROR(iAppThread.Open(iMainId));
 156 }
 157
 158 void CSdlAppServ::SetParam(int aParam)
 159 {
 160         iReturnValue = aParam;
 161 }
 162
 163 void CSdlAppServ::RunL()
 164 {
 165         if(iStatus == KErrNone)
 166         {
 167                 switch(iService)
 168                 {
 169                         case CSdlAppServ::EAppSrvStopThread:
 170                                 if(gEpocEnv->iDsa != NULL)
 171                                         gEpocEnv->iDsa->SetSuspend();
 172                                 break;
 173
 174                         case EAppSrvDsaStatus:
 175                                 if(gEpocEnv->iDsa != NULL)
 176                                         gEpocEnv->iDsa->Stop();
 177                                 iReturnValue = KErrNone;
 178                                 break;
 179
 180                         default:
 181                                 PANIC(KErrNotSupported);
 182                                 break;
 183                 }
 184
 185                 iStatus = KRequestPending;
 186                 iStatusPtr = &iStatus;
 187                 SetActive();
 188         }
 189 }
 190
 191 void CSdlAppServ::DoCancel()
 192 {
 193         TRequestStatus* s = &iStatus;
 194         iAppThread.RequestComplete(s, KErrCancel);
 195 }
 196
 197 CEventQueue& EpocSdlEnv::EventQueue()
 198 {
 199         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 200         return *gEpocEnv->iEventQueue;
 201 }
 202
 203 TBool EpocSdlEnv::IsDsaAvailable()
 204 {
 205         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 206         return gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->IsDsaAvailable();
 207 }
 208
 209 void EpocSdlEnv::WaitDsaAvailable()
 210 {
 211         gEpocEnv->iAppSrv->Request(CSdlAppServ::EAppSrvStopThread);
 212 }
 213
 214 int EpocSdlEnv::AllocSurface(const TSize& aSize, TDisplayMode aMode)
 215 {
 216         return gEpocEnv->iDsa->AllocSurface(aSize, aMode);
 217 }
 218
 219 void EpocSdlEnv::UnlockHwSurface()
 220 {
 221         gEpocEnv->iDsa->UnlockHwSurface();
 222 }
 223
 224 TUint8* EpocSdlEnv::LockHwSurface()
 225 {
 226         return gEpocEnv->iDsa->LockHwSurface();
 227 }
 228
 229 void EpocSdlEnv::UpdateSwSurface()
 230 {
 231         gEpocEnv->iDsa->UpdateSwSurface();
 232 }
 233
 234 TBool EpocSdlEnv::AddUpdateRect(TUint8* aAddress, const TRect& aUpdateRect, const TRect& aRect)
 235 {
 236         return gEpocEnv->iDsa->AddUpdateRect(aAddress, aUpdateRect, aRect);
 237 }
 238
 239 void EpocSdlEnv::Request(int aService)
 240 {
 241         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 242         gEpocEnv->iAppSrv->Request(aService);
 243 }
 244
 245 TDisplayMode EpocSdlEnv::DisplayMode()
 246 {
 247         return gEpocEnv->iDsa == NULL ? ENone : gEpocEnv->iDsa->DisplayMode();
 248 }
 249
 250 int EpocSdlEnv::SetPalette(int aFirstcolor, int aColorCount, TUint32* aPalette)
 251 {
 252         return  gEpocEnv->iDsa->SetPalette(aFirstcolor, aColorCount, aPalette);
 253 }
 254
 255 int EpocSdlEnv::AppendCleanupItem(const TSdlCleanupItem& aItem)
 256 {
 257         TRAPD(err, gEpocEnv->iCleanupItems->AppendL(aItem));
 258         return err;
 259 }
 260
 261 void EpocSdlEnv::RemoveCleanupItem(void* aItem)
 262 {
 263         for(int i = 0; i < gEpocEnv->iCleanupItems->Count(); i++)
 264         {
 265                 if(gEpocEnv->iCleanupItems->At(i).iItem == aItem)
 266                         gEpocEnv->iCleanupItems->Delete(i);
 267         }
 268 }
 269
 270 void EpocSdlEnv::CleanupItems()
 271 {
 272         const TThreadId id = RThread().Id();
 273         int last = gEpocEnv->iCleanupItems->Count() - 1;
 274         int i;
 275
 276         for(i = last; i >= 0 ; i--)
 277         {
 278                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 279                 if(item.iThread == id)
 280                 {
 281                         item.iThread = TThreadId(0);
 282                         item.iOperation(item.iItem);
 283                 }
 284         }
 285
 286         last = gEpocEnv->iCleanupItems->Count() - 1;
 287
 288         for(i = last; i >= 0 ; i--)
 289         {
 290                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 291                 if(item.iThread == TThreadId(0))
 292                 {
 293                         gEpocEnv->iCleanupItems->Delete(i);
 294                 }
 295         }
 296 }
 297
 298 void EpocSdlEnv::FreeSurface()
 299 {
 300         Request(CSdlAppServ::EAppSrvDsaStatus);
 301         if(gEpocEnv->iDsa != NULL)
 302                 gEpocEnv->iDsa->Free();
 303 }
 304
 305 static TBool CheckSdl()
 306 {
 307         int isExit = ETrue;
 308         RThread sdl;
 309         if(sdl.Open(gEpocEnv->iId) == KErrNone)
 310         {
 311                 if(sdl.ExitType() == EExitPending)
 312                 {
 313                         isExit = EFalse;
 314                 }
 315                 sdl.Close();
 316         }
 317         return isExit;
 318 }
 319
 320 void EpocSdlEnvData::Free()
 321 {
 322         if(RThread().Id() == gEpocEnv->iId)
 323         {
 324                 if(iDsa != NULL)
 325                         iDsa->Free();
 326                 return;
 327         }
 328
 329         __ASSERT_ALWAYS(CheckSdl(), PANIC(KErrNotReady));
 330 }
 331
 332 void EpocSdlEnvData::Delete()
 333 {
 334         delete iEventQueue;
 335
 336         if(iDsa != NULL)
 337                 iDsa->Free();
 338
 339         delete iDsa;
 340         delete iAppSrv;
 341 }
 342
 343 static int MainL()
 344 {
 345         gEpocEnv->iCleanupItems = new CArrayFixFlat<TSdlCleanupItem>(8);
 346
 347         char** envp = 0;
 348         char** argv = new char*[1];
 349         argv[0] = new char[8];
 350         strcpy(argv[0], "app.exe");
 351
 352         TMainFunc iMain = SDL_main;
 353
 354         /* !! process exits here if there is "exit()" in main! */
 355         int ret = 0;
 356         for(int i = 0; i < 6; i++)
 357         {
 358                 void* f = (void*) iMain[i];
 359                 if(f != NULL)
 360                 {
 361                         switch(i)
 362                         {
 363                                 case 0:
 364                                         ret = ((mainfunc1)f)();
 365                                         break;
 366
 367                                 case 3:
 368                                         ((mainfunc1)f)();
 369                                         break;
 370
 371                                 case 1:
 372                                         ret = ((mainfunc2)f)(1, argv);
 373                                         break;
 374
 375                                 case 4:
 376                                         ((mainfunc2)f)(1, argv);
 377                                         break;
 378
 379                                 case 2:
 380                                         ret = ((mainfunc3)f)(1, argv, envp);
 381                                         break;
 382
 383                                 case 5:
 384                                         ((mainfunc3)f)(1, argv, envp);
 385                                         break;
 386
 387                                 default:
 388                                         break;
 389                         }
 390
 391                         delete[] argv[0];
 392                         delete[] argv;
 393                         return ret;
 394                 }
 395         }
 396
 397         PANIC(KErrNotFound);
 398         return 0;
 399 }
 400
 401 static int DoMain()
 402 {
 403         gEpocEnv->iAppSrv->Init();
 404
 405         TRAPD(err, err = MainL());
 406
 407         // Free resources and return
 408         EpocSdlEnv::CleanupItems();
 409
 410         gEpocEnv->iCleanupItems->Reset();
 411         delete gEpocEnv->iCleanupItems;
 412         gEpocEnv->iCleanupItems = NULL;
 413
 414         gEpocEnv->Free(); //free up in thread resources
 415
 416         return err;
 417 }
 418
 419 CSDL::CSDL()
 420 {
 421         __ASSERT_ALWAYS(gEpocEnv == NULL, PANIC(KErrAlreadyExists));
 422         gEpocEnv = new EpocSdlEnvData;
 423         Mem::FillZ(gEpocEnv, sizeof(EpocSdlEnvData));
 424
 425         gEpocEnv->iEventQueue = new CEventQueue();
 426         gEpocEnv->iAppSrv = new CSdlAppServ();
 427
 428         gEpocEnv->iSdl = this;
 429 }
 430
 431 CSDL::~CSDL()
 432 {
 433         gEpocEnv->Free();
 434         gEpocEnv->Delete();
 435
 436         delete gEpocEnv;
 437         gEpocEnv = NULL;
 438 }
 439
 440 void CSDL::SetContainerWindowL(RWindow& aWindow, RWsSession& aSession, CWsScreenDevice& aDevice)
 441 {
 442         if(gEpocEnv->iDsa == NULL)
 443                 gEpocEnv->iDsa = CDsa::CreateL(aSession);
 444         gEpocEnv->iDsa->ConstructL(aWindow, aDevice);
 445 }
 446
 447 int EpocSdlEnv::ApplyGlesDsa()
 448 {
 449         CDsa* dsa = NULL;
 450         TRAPD(err, dsa = gEpocEnv->iDsa->CreateGlesDsaL());
 451         gEpocEnv->iDsa = dsa;
 452         return err;
 453 }
 454
 455 RWindow* EpocSdlEnv::Window()
 456 {
 457         return gEpocEnv->iDsa->Window();
 458 }
 459
 460 void EpocSdlEnv::UpdateWholeScreen(bool val)
 461 {
 462         gEpocEnv->iDsa->m_updateWholeScreen = val;
 463 }
 464
 465 bool EpocSdlEnv::GetUpdateWholeScreen()
 466 {
 467         return gEpocEnv->iDsa->m_updateWholeScreen;
 468 }
 469
 470 void EpocSdlEnv::SetOrientation(CAknAppUi::TAppUiOrientation orientation, const TSize& aSize, TDisplayMode aMode)
 471 {
 472         gEpocEnv->iWaitingForOrientationChange = true;
 473         gEpocEnv->iSize = aSize;
 474         gEpocEnv->iMode = aMode;
 475
 476         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(orientation));
 477 }
 478
 479 void CSDL::CallMainL()
 480 {
 481         ASSERT(gEpocEnv != NULL);
 482
 483         gEpocEnv->iAppSrv->ConstructL();
 484
 485         // for handling volume up/down keys
 486         CRemConInterfaceSelector *iSelector = CRemConInterfaceSelector::NewL();
 487         CRemConCoreApiTarget::NewL( *iSelector, *this );
 488         iSelector->OpenTargetL();
 489
 490         gEpocEnv->iId = RThread().Id();
 491         // when priority is not lowered screen updates much more frequently, which
 492         // may be undesired, for example in case of openttd's generating world dialog
 493         RThread().SetPriority(EPriorityLess);
 494         DoMain();
 495 }
 496
 497 void CSDL::AppendWsEvent(const TWsEvent& aEvent)
 498 {
 499         EpocSdlEnv::EventQueue().Append(aEvent);
 500 }
 501
 502 void CSDL::Resize()
 503 {
 504         if(gEpocEnv->iWaitingForOrientationChange)
 505         {
 506                 EpocSdlEnv::AllocSurface(gEpocEnv->iSize, gEpocEnv->iMode);
 507                 gEpocEnv->iWaitingForOrientationChange = false;
 508         }
 509         else
 510         {
 511                 TSize size = gEpocEnv->iDsa->Window()->Size();
 512                 SDL_PrivateResize(size.iWidth, size.iHeight);
 513         }
 514 }
 515
 516 void CSDL::MrccatoCommand(TRemConCoreApiOperationId aOperationId, TRemConCoreApiButtonAction aButtonAct)
 517 {
 518         if(aButtonAct != ERemConCoreApiButtonClick)
 519                 return;
 520
 521         TWsEvent event;
 522         event.SetType(EEventKey);
 523         event.SetTimeNow();
 524
 525         switch(aOperationId)
 526         {
 527         case ERemConCoreApiVolumeDown:
 528                 event.Key()->iScanCode = EStdKeyDecVolume;
 529                 event.SetType(EEventKeyDown);
 530                 AppendWsEvent(event);
 531                 event.SetType(EEventKeyUp);
 532                 AppendWsEvent(event);
 533                 break;
 534
 535         case ERemConCoreApiVolumeUp:
 536                 event.Key()->iScanCode = EStdKeyIncVolume;
 537                 event.SetType(EEventKeyDown);
 538                 AppendWsEvent(event);
 539                 event.SetType(EEventKeyUp);
 540                 AppendWsEvent(event);
 541                 break;
 542
 543         default:
 544                 break;
 545         }
 546 }