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 #include "ProfileWatcher.h"
  21
  22 CSDL* g_SDL = NULL;
  23
  24 class CCurrentAppUi;
  25 class CEikonEnv;
  26 class CSdlAppServ;
  27 class CEventQueue;
  28
  29 class EpocSdlEnvData
  30 {
  31         public:
  32                 void Free();
  33                 void Delete();
  34                 CDsa*                   iDsa;
  35                 CSdlAppServ*            iAppSrv;
  36                 CArrayFix<TSdlCleanupItem>* iCleanupItems;
  37 };
  38
  39 EpocSdlEnvData* gEpocEnv;
  40
  41 static void RunSingleThread()
  42 {
  43         if(RThread().RequestCount() > 0)
  44         {
  45                 int err;
  46                 if(CActiveScheduler::RunIfReady(err, CActive::EPriorityIdle))
  47                 {
  48                         CActiveScheduler::Current()->WaitForAnyRequest();
  49                 }
  50         }
  51 }
  52
  53 int Panic(int aErr, int aLine)
  54 {
  55         TBuf<64> b;
  56         b.Format(_L("Main at %d"), aLine);
  57         User::Panic(b, aErr);
  58         return 0;
  59 }
  60
  61 bool CEventQueue::HasData()
  62 {
  63         RunSingleThread();
  64         return !m_queue.empty();
  65 }
  66
  67 const TWsEvent CEventQueue::Shift()
  68 {
  69         const TWsEvent event = m_queue.front();
  70         m_queue.pop();
  71         return event;
  72 }
  73
  74
  75 TSdlCleanupItem::TSdlCleanupItem(TSdlCleanupOperation aOperation, void* aItem) :
  76         iOperation(aOperation), iItem(aItem), iThread(RThread().Id())
  77 {}
  78
  79
  80 ProfileWatcher::ProfileWatcher(MProfileWatcher& observer)
  81         : CActive(EPriorityLow)
  82         , m_repository(CRepository::NewL(KCRUidProfileEngine))
  83         , m_observer(observer)
  84 {
  85         CActiveScheduler::Add(this);
  86         m_repository->NotifyRequest(KProEngActiveProfile, iStatus);
  87         SetActive();
  88 }
  89
  90 ProfileWatcher::~ProfileWatcher()
  91 {
  92         Cancel();
  93         delete m_repository;
  94 }
  95
  96 void ProfileWatcher::DoCancel()
  97 {
  98         m_repository->NotifyCancel(KProEngActiveProfile);
  99 }
 100
 101 void ProfileWatcher::RunL()
 102 {
 103         int value;
 104         if(m_repository->Get(KProEngActiveProfile, value) == KErrNone)
 105         {
 106                 m_observer.ProfileChanged(value);
 107         }
 108         m_repository->NotifyRequest(KProEngActiveProfile, iStatus);
 109         SetActive();
 110 }
 111
 112
 113 class CSdlAppServ : public CActive
 114 {
 115         public:
 116                 CSdlAppServ() : CActive(CActive::EPriorityIdle)
 117                 {
 118                         CActiveScheduler::Add(this);
 119                         SetActive();
 120                 }
 121                 ~CSdlAppServ() { Cancel(); }
 122                 void Request()
 123                 {
 124                         TRequestStatus* status = &iStatus;
 125                         User::RequestComplete(status, KErrNone);
 126                 }
 127
 128         private:
 129                 void RunL() {}
 130                 void DoCancel()
 131                 {
 132                         TRequestStatus* status = &iStatus;
 133                         User::RequestComplete(status, KErrCancel);
 134                 }
 135 };
 136
 137 bool EpocSdlEnv::IsDsaAvailable()
 138 {
 139         __ASSERT_DEBUG(gEpocEnv != NULL, PANIC(KErrNotReady));
 140         return gEpocEnv->iDsa != NULL && gEpocEnv->iDsa->IsDsaAvailable();
 141 }
 142
 143 int EpocSdlEnv::AllocSurface(const TSize& aSize, TDisplayMode aMode)
 144 {
 145         return gEpocEnv->iDsa->AllocSurface(aSize, aMode);
 146 }
 147
 148 void EpocSdlEnv::UnlockHwSurface()
 149 {
 150         gEpocEnv->iDsa->UnlockHwSurface();
 151 }
 152
 153 TUint8* EpocSdlEnv::LockHwSurface()
 154 {
 155         return gEpocEnv->iDsa->LockHwSurface();
 156 }
 157
 158 void EpocSdlEnv::UpdateSwSurface()
 159 {
 160         gEpocEnv->iDsa->UpdateSwSurface();
 161 }
 162
 163 bool EpocSdlEnv::AddUpdateRect(TUint8* aAddress, const TRect& aUpdateRect, const TRect& aRect)
 164 {
 165         return gEpocEnv->iDsa->AddUpdateRect(aAddress, aUpdateRect, aRect);
 166 }
 167
 168 TDisplayMode EpocSdlEnv::DisplayMode()
 169 {
 170         return gEpocEnv->iDsa == NULL ? ENone : gEpocEnv->iDsa->DisplayMode();
 171 }
 172
 173 int EpocSdlEnv::SetPalette(int aFirstcolor, int aColorCount, TUint32* aPalette)
 174 {
 175         return  gEpocEnv->iDsa->SetPalette(aFirstcolor, aColorCount, aPalette);
 176 }
 177
 178 int EpocSdlEnv::AppendCleanupItem(const TSdlCleanupItem& aItem)
 179 {
 180         TRAPD(err, gEpocEnv->iCleanupItems->AppendL(aItem));
 181         return err;
 182 }
 183
 184 void EpocSdlEnv::RemoveCleanupItem(void* aItem)
 185 {
 186         for(int i = 0; i < gEpocEnv->iCleanupItems->Count(); i++)
 187         {
 188                 if(gEpocEnv->iCleanupItems->At(i).iItem == aItem)
 189                         gEpocEnv->iCleanupItems->Delete(i);
 190         }
 191 }
 192
 193 void EpocSdlEnv::CleanupItems()
 194 {
 195         const TThreadId id = RThread().Id();
 196         int last = gEpocEnv->iCleanupItems->Count() - 1;
 197         int i;
 198
 199         for(i = last; i >= 0 ; i--)
 200         {
 201                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 202                 if(item.iThread == id)
 203                 {
 204                         item.iThread = TThreadId(0);
 205                         item.iOperation(item.iItem);
 206                 }
 207         }
 208
 209         last = gEpocEnv->iCleanupItems->Count() - 1;
 210
 211         for(i = last; i >= 0 ; i--)
 212         {
 213                 TSdlCleanupItem& item = gEpocEnv->iCleanupItems->At(i);
 214                 if(item.iThread == TThreadId(0))
 215                 {
 216                         gEpocEnv->iCleanupItems->Delete(i);
 217                 }
 218         }
 219 }
 220
 221 void EpocSdlEnv::FreeSurface()
 222 {
 223         gEpocEnv->iAppSrv->Request();
 224
 225         if(gEpocEnv->iDsa != NULL)
 226         {
 227                 gEpocEnv->iDsa->Stop();
 228                 gEpocEnv->iDsa->Free();
 229         }
 230 }
 231
 232 void EpocSdlEnvData::Free()
 233 {
 234         if(iDsa != NULL)
 235                 iDsa->Free();
 236 }
 237
 238 void EpocSdlEnvData::Delete()
 239 {
 240         if(iDsa != NULL)
 241                 iDsa->Free();
 242
 243         delete iDsa;
 244         delete iAppSrv;
 245 }
 246
 247 static int MainL()
 248 {
 249         gEpocEnv->iCleanupItems = new CArrayFixFlat<TSdlCleanupItem>(8);
 250
 251         char** argv = new char*[1];
 252         argv[0] = new char[8];
 253         strcpy(argv[0], "app.exe");
 254
 255         int ret = SDL_main( 1, argv );
 256
 257         delete[] argv[0];
 258         delete[] argv;
 259
 260         return ret;
 261 }
 262
 263 static int DoMain()
 264 {
 265         TRAPD(err, err = MainL());
 266
 267         // Free resources and return
 268         EpocSdlEnv::CleanupItems();
 269
 270         gEpocEnv->iCleanupItems->Reset();
 271         delete gEpocEnv->iCleanupItems;
 272         gEpocEnv->iCleanupItems = NULL;
 273
 274         gEpocEnv->Free(); //free up in thread resources
 275
 276         return err;
 277 }
 278
 279 CSDL::CSDL()
 280         : m_orientationWait( false )
 281         , m_soundPauseReason( SPR_NONE )
 282         , m_profileWatcher( new ProfileWatcher(*this) )
 283 {
 284         __ASSERT_ALWAYS(gEpocEnv == NULL, PANIC(KErrAlreadyExists));
 285         gEpocEnv = new EpocSdlEnvData;
 286         Mem::FillZ(gEpocEnv, sizeof(EpocSdlEnvData));
 287
 288         m_eventQueue = new CEventQueue();
 289
 290         gEpocEnv->iAppSrv = new CSdlAppServ();
 291
 292         g_SDL = this;
 293 }
 294
 295 CSDL::~CSDL()
 296 {
 297         delete m_profileWatcher;
 298
 299         g_SDL = NULL;
 300
 301         delete m_eventQueue;
 302
 303         gEpocEnv->Free();
 304         gEpocEnv->Delete();
 305
 306         delete gEpocEnv;
 307         gEpocEnv = NULL;
 308 }
 309
 310 void CSDL::SetContainerWindowL(RWindow& aWindow, RWsSession& aSession, CWsScreenDevice& aDevice)
 311 {
 312         if(gEpocEnv->iDsa == NULL)
 313                 gEpocEnv->iDsa = CDsa::CreateL(aSession);
 314         gEpocEnv->iDsa->ConstructL(aWindow, aDevice);
 315 }
 316
 317 int EpocSdlEnv::ApplyGlesDsa()
 318 {
 319         CDsa* dsa = NULL;
 320         TRAPD(err, dsa = gEpocEnv->iDsa->CreateGlesDsaL());
 321         gEpocEnv->iDsa = dsa;
 322         return err;
 323 }
 324
 325 RWindow* EpocSdlEnv::Window()
 326 {
 327         return gEpocEnv->iDsa->Window();
 328 }
 329
 330 void CSDL::CallMainL()
 331 {
 332         ASSERT(gEpocEnv != NULL);
 333
 334         // for handling volume up/down keys
 335         CRemConInterfaceSelector *iSelector = CRemConInterfaceSelector::NewL();
 336         CRemConCoreApiTarget::NewL( *iSelector, *this );
 337         iSelector->OpenTargetL();
 338
 339         // when priority is not lowered screen updates much more frequently, which
 340         // may be undesired, for example in case of openttd's generating world dialog
 341         RThread().SetPriority(EPriorityLess);
 342         DoMain();
 343 }
 344
 345 void CSDL::AppendWsEvent(const TWsEvent& aEvent)
 346 {
 347         m_eventQueue->Append(aEvent);
 348 }
 349
 350 void CSDL::Resize()
 351 {
 352         if(m_orientationWait)
 353         {
 354                 EpocSdlEnv::AllocSurface(m_size, m_mode);
 355                 m_orientationWait = false;
 356         }
 357         else
 358         {
 359                 TSize size = gEpocEnv->iDsa->Window()->Size();
 360                 SDL_PrivateResize(size.iWidth, size.iHeight);
 361         }
 362 }
 363
 364 void CSDL::SetOrientation(CAknAppUi::TAppUiOrientation orientation, const TSize& aSize, TDisplayMode aMode)
 365 {
 366         m_orientationWait = true;
 367         m_size = aSize;
 368         m_mode = aMode;
 369
 370         TRAPD(err, static_cast<CAknAppUi*>(CEikonEnv::Static()->EikAppUi())->SetOrientationL(orientation));
 371 }
 372
 373 void CSDL::SetFocus(bool focused)
 374 {
 375         if(focused)
 376         {
 377                 m_soundPauseReason &= ~SPR_FOCUSLOST;
 378         }
 379         else
 380         {
 381                 m_soundPauseReason |= SPR_FOCUSLOST;
 382         }
 383 }
 384
 385 void CSDL::MrccatoCommand(TRemConCoreApiOperationId aOperationId, TRemConCoreApiButtonAction aButtonAct)
 386 {
 387         if(aButtonAct != ERemConCoreApiButtonClick)
 388                 return;
 389
 390         TWsEvent event;
 391         event.SetType(EEventKey);
 392         event.SetTimeNow();
 393
 394         switch(aOperationId)
 395         {
 396         case ERemConCoreApiVolumeDown:
 397                 event.Key()->iScanCode = EStdKeyDecVolume;
 398                 event.SetType(EEventKeyDown);
 399                 AppendWsEvent(event);
 400                 event.SetType(EEventKeyUp);
 401                 AppendWsEvent(event);
 402                 break;
 403
 404         case ERemConCoreApiVolumeUp:
 405                 event.Key()->iScanCode = EStdKeyIncVolume;
 406                 event.SetType(EEventKeyDown);
 407                 AppendWsEvent(event);
 408                 event.SetType(EEventKeyUp);
 409                 AppendWsEvent(event);
 410                 break;
 411
 412         default:
 413                 break;
 414         }
 415 }
 416
 417 void CSDL::ProfileChanged(int profile)
 418 {
 419         // Check for silent profile
 420         if(profile == 1)
 421         {
 422                 m_soundPauseReason |= SPR_SILENTPROFILE;
 423         }
 424         else
 425         {
 426                 m_soundPauseReason &= ~SPR_SILENTPROFILE;
 427         }
 428 }