src/GlTimerBase.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file                GlTimerBase.cpp
  19  * @brief               This is the source file for GlTimerBase class.
  20  */
  21
  22 #include <FBase.h>
  23 #include <FUi.h>
  24
  25 #include "GlContentUpdateEventListener.h"
  26 #include "GlProgressBar.h"
  27 #include "GlTimerBase.h"
  28 #include "GlTypes.h"
  29
  30 using namespace Tizen::Ui;
  31 using namespace Tizen::Base::Runtime;
  32
  33 GlTimerBase::GlTimerBase(IFileOpInvalidateListener* invalidateListener, enum FileActionMode actionId)
  34         : _actionId(actionId)
  35         , __pContentIdList(null)
  36         , __moveToCount(0)
  37         , __pMoveProBar(null)
  38         , __pInvalidate(invalidateListener)
  39 {
  40         AppLogDebug("ENTER");
  41         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
  42 }
  43
  44 GlTimerBase::~GlTimerBase(void)
  45 {
  46         AppLogDebug("ENTER");
  47         __pInvalidate = null;
  48         if (__pContentIdList != null && __pContentIdList->GetCount() > 0)
  49         {
  50                 __moveTimer.Cancel();
  51         }
  52         delete __pContentIdList;
  53         AppLogDebug("ENTER");
  54 }
  55
  56 bool
  57 GlTimerBase::StartTimer(void)
  58 {
  59         AppLogDebug("ENTER");
  60         __pContentIdList = TimerStart();
  61         if (__pContentIdList != null && __pContentIdList->GetCount() > 0)
  62         {
  63                 AppLogDebug("Starting timer");
  64                 __pMoveProBar = new (std::nothrow) GlProgressBar(static_cast<IActionEventListener*>(this));
  65                 __pMoveProBar->ShowFileProgressingPopup(__pContentIdList->GetCount(), _actionId);
  66                 __moveToCount = 0;
  67                 __moveTimer.Construct(*this);
  68                 __moveTimer.Start(1);
  69                 ContentUpdateEventListener* pContentListener = ContentUpdateEventListener::GetInstance();
  70                 pContentListener->RemoveContentListener();
  71                 AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
  72                 return E_SUCCESS;
  73         }
  74         AppLogDebug("EXIT1(%s)", GetErrorMessage(GetLastResult()));
  75         return E_FAILURE;
  76 }
  77
  78 void
  79 GlTimerBase::CancelTimer(void)
  80 {
  81         AppLogDebug("ENTER");
  82         __moveTimer.Cancel();
  83         OnOpCancelled(CANCEL_USER);
  84         __moveToCount = 0;
  85         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
  86 }
  87
  88 void
  89 GlTimerBase::OnTimerExpired(Timer& timer)
  90 {
  91         AppLogDebug("ENTER");
  92         if (&timer == &__moveTimer)
  93         {
  94                 AppLogDebug("__pContentIdList count is %d", __pContentIdList->GetCount());
  95                 if (__moveToCount < __pContentIdList->GetCount())
  96                 {
  97                         AppLogDebug("__pContentIdList count is %d", __pContentIdList->GetCount());
  98                         if (__pContentIdList->GetAt(__moveToCount) != null)
  99                         {
 100                                 result r = TimerExpired(__pContentIdList->GetAt(__moveToCount));
 101                                 if (IsFailed(r))
 102                                 {
 103                                         AppLogDebug("OnTimerExpired EXIT(%s)", GetErrorMessage(r));
 104                                         OnOpCancelled(CANCEL_SYS_ERROR);
 105                                         return;
 106                                 }
 107                         }
 108                         __moveToCount++;
 109                         __pMoveProBar->IncProgress(__moveToCount);
 110                         if (__pInvalidate)
 111                         {
 112                                 __pInvalidate->OnFileOpInvalidate(_actionId);
 113                         }
 114                         __moveTimer.Start(1);
 115                 }
 116                 else
 117                 {
 118                         __moveTimer.Cancel();
 119                         OnOpComplete(COMPLETE_SUCCESS);
 120                         __moveToCount = 0;
 121                 }
 122         }
 123         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 124 }
 125
 126 void
 127 GlTimerBase::OnActionPerformed(const Control& source, int actionId)
 128 {
 129         AppLogDebug("ENTER");
 130         switch (actionId)
 131         {
 132         case IDA_PROGRESSBAR_CANCEL:
 133         {
 134                 CancelTimer();
 135         }
 136         break;
 137
 138         default:
 139                 break;
 140         }
 141         AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 142 }
 143
 144
 145 void GlTimerBase::OnOpCancelled(enum FileActionCancelRes res)
 146 {
 147         AppLogDebug("ENTER");
 148         __pMoveProBar->HideFileProgressingPopup();
 149         ContentUpdateEventListener* pContentListener = ContentUpdateEventListener::GetInstance();
 150         pContentListener->AddContentListener();
 151         if (__pInvalidate)
 152         {
 153                 __pInvalidate->OnFileOpInvalidate(_actionId);
 154         }
 155         if (__moveToCount > 0)
 156         {
 157                 if (__pInvalidate)
 158                 {
 159                         if (res != CANCEL_USER)
 160                         {
 161                                 __pInvalidate->OnFileOpComplete(_actionId, COMPLETE_SYS_PARTIAL);
 162                         }
 163                         else
 164                         {
 165                                 __pInvalidate->OnFileOpComplete(_actionId, COMPLETE_SUCCESS);
 166                         }
 167                 }
 168         }
 169         else
 170         {
 171                 if (__pInvalidate)
 172                 {
 173                         if (res != CANCEL_USER)
 174                         {
 175                                 __pInvalidate->OnFileOpComplete(_actionId, COMPLETE_SYS_FAILURE);
 176                         }
 177                         else
 178                         {
 179                                 __pInvalidate->OnFileOpComplete(_actionId, COMPLETE_SUCCESS);
 180                         }
 181                 }
 182         }
 183         TimerCancel(__moveToCount, res);
 184         AppLogDebug("EXIT");
 185 }
 186
 187 void GlTimerBase::OnOpComplete(enum FileActionCompleteRes res)
 188 {
 189         AppLogDebug("ENTER");
 190         ContentUpdateEventListener* pContentListener = ContentUpdateEventListener::GetInstance();
 191         pContentListener->AddContentListener();
 192         __pMoveProBar->HideFileProgressingPopup();
 193         if (__pInvalidate)
 194         {
 195                 __pInvalidate->OnFileOpInvalidate(_actionId);
 196                 __pInvalidate->OnFileOpComplete(_actionId, res);
 197         }
 198         TimerComplete(__moveToCount, res);
 199         AppLogDebug("EXIT");
 200 }
 201
 202 void GlTimerBase::SetActionMode(const enum FileActionMode actionId)
 203 {
 204         _actionId = actionId;
 205 }