#include "CmTypes.h"
#include "CmCameraApp.h"
+#include "CmCameraPresentationModel.h"
class BaseForm :
public Tizen::Ui::Controls::Form
result ReturnValues(RequestId requestId, Tizen::App::AppCtrlResult appCtrlResult, const Tizen::Base::Collection::IMap* pReturnValue);
Tizen::Telephony::CallStatus GetCurrentCallStatus(void);
Tizen::Telephony::CallType GetCurrentCallType(void);
+ void BaseFormOnActionPerformed(const Tizen::Ui::Control& source, int actionId);
+ result SendAppControlResult(RequestId requestId);
+ result LaunchAppControl(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::String* pUriData, const Tizen::Base::String* pDataType, const Tizen::Base::Collection::IMap* extraData);
+ virtual void OnAppControlCompleted(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::Collection::IList* pResultList);
+ void SetStorageType(int storageType);
+ void ShowCameraFailPopup(void);
+ void ShowUnlaunchPopup(void);
+ void ShowLowBatteryPopup(void);
+ result TerminateApp(void);
+ void RemoveAllEventListener(void);
+ void DeleteTimer(void);
+
+protected:
+ CameraPresentationModel* _pCameraPresentationModel;
+ SourceForm _pCurrentSourceForm;
+ int _timeCount;
+ bool _isRecording;
+ bool _isRecordingPause;
+ int _chargingCount;
+ int _blinkCount;
+ bool _appControlActionCompleted;
+ bool _isUsedTimerCaptured;
+ int _closeTimerValue;
+
+ Tizen::Base::Runtime::Timer* _pAppTimer;
+ Tizen::Base::Runtime::Timer* _pIntervalValueTimer;
+ Tizen::Base::Runtime::Timer* _pCaptureStartTimer;
+ Tizen::Base::Runtime::Timer* _pPopupTimer;
+ Tizen::Base::Runtime::Timer* _pExposureCloseTimer;
+ Tizen::Base::Runtime::Timer* _pTouchAutoFocusTimer;
+ Tizen::Base::Runtime::Timer* _pHelpCloseTimer;
+ Tizen::Base::Runtime::Timer* _pChargingTimer;
+ Tizen::Base::Runtime::Timer* _pChargingCompletedTimer;
+ Tizen::Base::Runtime::Timer* _pPreviewFailPopupTimer;
+ Tizen::Base::Runtime::Timer* _pMakerFocusTimer;
};
#endif
virtual bool DeleteItem(int index, Tizen::Ui::Controls::ListItemBase* pItem, int itemWidth);
virtual int GetItemCount(void);
- virtual void OnKeyPressed(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode);
- virtual void OnKeyReleased(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode);
- virtual void OnKeyLongPressed(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode);
-
virtual result OnInitializing(void);
virtual result OnTerminating(void);
virtual void OnOrientationChanged(const Tizen::Ui::Control& source, Tizen::Ui::OrientationStatus orientationStatus);
- virtual void OnAppControlCompleted(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::Collection::IList* pResultList);
-
virtual void OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs);
virtual void OnFileEventOccured(const unsigned long events, const Tizen::Base::String& path, const unsigned int eventId);
int GetTimerIntervalValue(void) const;
void SetGuideLine(int guideLineEnable);
void SetStartRecording(void);
- void SetStorageType(int storageType);
result RestoreDefaultSetting(void);
result SetRecordStartTimer(int timerInterval);
void HideUiModeChangedButton(void);
void CheckStorageInfo(void);
- result LaunchAppControl(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::String* pUriData, const Tizen::Base::String* pDataType, const Tizen::Base::Collection::IMap* extraData);
void SetCamcorderMode(void);
result CreateOverlayRegion(Tizen::Graphics::Rectangle rect);
result SetOverlayPanel(Tizen::Graphics::Rectangle rect, Tizen::Graphics::Rectangle evaluateBoundsRect, Tizen::Graphics::Rectangle clientRect, bool destroyOverlay, bool isWideMode);
void GetCameraToForeground(void);
void SendCameraToBackground(void);
void DrawThumbnail(void);
- void ShowUnlaunchPopup(void);
void ShowCameraFailPopup(void);
void ShowSavingPopup(void);
void StartChargingTimer(void);
result DrawBatteryLevelFull(void);
result CheckBatteryStatus(void);
- void ShowLowBatteryPopup(void);
result MakeMenuString(void);
result MakeGenMenuString(void);
- result SendAppControlResult(RequestId requestId);
result RunStartPreviewThread(void);
void MakeRecordingResolutionList(bool remakeList);
void CancelTimer(void);
- void DeleteTimer(void);
void OnAppTimerExpired(void);
void OnSettingTimerExpired(void);
void OnPopupTimerExpired(void);
result SetScreenOverlayHelpTimer(void);
void HideScreenOverlayHelp(void);
result DrawScreenOverlayHelp(void);
- result TerminateApp(void);
- void RemoveAllEventListener(void);
void ReInitialise(void);
void UpdatePopUp(void);
static const int IDA_BTN_YES = 603;
static const int IDA_BTN_NO = 604;
- CameraPresentationModel* __pCamcorderPresentationModel;
ScreenMode __screenMode;
Tizen::Ui::Controls::OverlayPanel* __pOverlayPanel;
- Tizen::Base::Runtime::Timer* __pAppTimer;
- Tizen::Base::Runtime::Timer* __pIntervalValueTimer;
Tizen::Base::Runtime::Timer* __pRecordTimer;
- Tizen::Base::Runtime::Timer* __pPopupTimer;
- Tizen::Base::Runtime::Timer* __pExposureCloseTimer;
- Tizen::Base::Runtime::Timer* __pMakerFocusTimer;
- Tizen::Base::Runtime::Timer* __pChargingTimer;
- Tizen::Base::Runtime::Timer* __pChargingCompletedTimer;
- Tizen::Base::Runtime::Timer* __pHelpCloseTimer;
- Tizen::Base::Runtime::Timer* __pPreviewFailPopupTimer;
Tizen::Ui::Controls::ListView* __pListViewCamcoderTabMainMenu;
Tizen::Ui::Controls::ListView* __pListViewCamcoderTabSubMenu;
Tizen::Ui::Controls::ListView* __pListViewGeneralTabMainMenu;
int __settingWhiteBalance;
int __settingTimeInterval;
int __settingExposure;
- int __timeCount;
long __recordTimeCount;
long __recordingMaxTime;
- int __closeTimerValue;
- bool __isRecording;
- bool __isRecordingPause;
+ int _closeTimerValue;
int __previewResolutionWidth;
int __previewResolutionHeight;
int __pRecordingResolutionWidth;
bool __isMemoryFull;
bool __isLockScreenMode;
bool __isOrientationChanged;
- int __chargingCount;
- int __blinkCount;
bool __doRecording;
BatteryState __batteryStatus;
Tizen::Ui::Controls::Panel* __pSettingPanel;
Tizen::Base::String __uri;
Tizen::Base::String __mime;
bool __isCapacityBelow;
- bool __appControlActionCompleted;
Tizen::Ui::Controls::Popup* __pCancelPopup;
bool __setTimerInterval;
Tizen::Graphics::Bitmap* __pRecordPauseBitmap;
virtual bool DeleteItem(int index, Tizen::Ui::Controls::ListItemBase* pItem, int itemWidth);
virtual int GetItemCount(void);
- virtual void OnKeyPressed(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode);
- virtual void OnKeyReleased(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode);
- virtual void OnKeyLongPressed(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode);
-
- virtual void OnSliderBarMoved(Tizen::Ui::Controls::Slider& source, int value);
- virtual void OnAdjustmentValueChanged(const Tizen::Ui::Control& source, int adjustment);
-
virtual void OnOrientationChanged(const Tizen::Ui::Control& source, Tizen::Ui::OrientationStatus orientationStatus);
-
- virtual void OnAppControlCompleted(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::Collection::IList* pResultList);
-
virtual void OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs);
virtual void OnFileEventOccured(const unsigned long events, const Tizen::Base::String& path, const unsigned int eventId);
result SetMenuTitle(Tizen::Graphics::Canvas* pCanvas, const Tizen::Base::String& str, const int fntSize);
int GetTimerIntervalValue(void) const;
void SetGuideLine(int guideLineEnable);
- void SetStorageType(int storageType);
result RestoreDefaultSetting(void);
result RestorePrimaryResolution(void);
Tizen::Ui::Controls::CustomItem* CreateItem4(int index, int itemWidth);
void SetCameraSettingsDevice(void);
- result LaunchAppControl(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::String* pUriData, const Tizen::Base::String* pDataType, const Tizen::Base::Collection::IMap* extraData);
-
void SetCameraMode(bool isWideMode);
void SetOverlayRendererRotation(void);
result CreateOverlayRegion(Tizen::Graphics::Rectangle rect);
void SendCameraToBackground(void);
void DrawThumbnail(void);
void SetCameraErrorOccurred(void);
- void ShowCameraFailPopup(void);
- void ShowUnlaunchPopup(void);
result DrawBatteryLevelFull(void);
- void ShowLowBatteryPopup(void);
int GetCurrentBatteryImage(void);
result CheckBatteryStatus(void);
result MakeCameraTabMenuString(void);
result MakeGeneralTabMenuString(void);
- void DeleteTimer(void);
void CancelTimer(void);
- result SendAppControlResult(RequestId requestId);
result RunStartPreviewThread(void);
result SubListPopupTimerMode(int index);
void HideScreenOverlayHelp();
result DrawScreenOverlayHelp(void);
void OnTimerCapturePause(void);
- result TerminateApp(void);
- void RemoveAllEventListener(void);
void UpdatePopUp(void);
bool CheckCallStatus(void);
static const int IDA_BTN_YES = 103;
static const int IDA_BTN_NO = 104;
- CameraPresentationModel* __pCameraPresentationModel;
Tizen::Ui::Controls::OverlayPanel* __pOverlayPanel;
ScreenMode __screenMode;
- Tizen::Base::Runtime::Timer* __pAppTimer;
- Tizen::Base::Runtime::Timer* __pIntervalValueTimer;
- Tizen::Base::Runtime::Timer* __pCaptureStartTimer;
- Tizen::Base::Runtime::Timer* __pPopupTimer;
- Tizen::Base::Runtime::Timer* __pExposureCloseTimer;
- Tizen::Base::Runtime::Timer* __pTouchAutoFocusTimer;
- Tizen::Base::Runtime::Timer* __pHelpCloseTimer;
- Tizen::Base::Runtime::Timer* __pChargingTimer;
- Tizen::Base::Runtime::Timer* __pChargingCompletedTimer;
- Tizen::Base::Runtime::Timer* __pPreviewFailPopupTimer;
Tizen::Ui::Controls::ListView* __pListViewCameraTabMainMenu;
Tizen::Ui::Controls::ListView* __pListViewCameraTabSubMenu;
Tizen::Ui::Controls::ListView* __pListViewGeneralTabMainMenu;
int __settingExposure;
int __primaryCurrentResolutionIndex;
int __secondaryCurrentResolutionIndex;
- int __timeCount;
- int __chargingCount;
- int __blinkCount;
bool __isTimerRunning;
- int __closeTimerValue;
- bool __isUsedTimerCaptured;
int __previewResolutionWidth;
int __previewResolutionHeight;
int __captureResolutionWidth;
Tizen::Io::FileEventManager* __pFileEventManager;
Tizen::Base::String __uri;
Tizen::Base::String __mime;
- bool __appControlActionCompleted;
bool __formStatusFrameDeattivated;
Tizen::Graphics::BufferInfo __bufferInfo;
Tizen::Base::String __pFileEventPath;
BATTERY_STATE_20,
};
+enum SourceForm
+{
+ SOURCE_FORM_CAMERA,
+ SOURCE_FORM_CAMCORDER
+};
+
extern const unsigned int COLOR_SETTING_MENU_TITLE;
extern const unsigned int COLOR_SETTING_MENU_VAULE;
extern const unsigned int COLOR_SETTING_MENU_VALUE_DISABLE;
extern const int APP_CONTROL_TYPE_STANDARD;
extern const int APP_CONTROL_TYPE_REQUESET;
+extern const int MESSAGEBOX_DISPLAY_TIME_2_SEC;
+extern const int MESSAGEBOX_DISPLAY_TIME_3_SEC;
+
extern const int FLASH_TYPE_OFF;
extern const int FLASH_TYPE_ON;
BaseForm::BaseForm(void)
+:_pCameraPresentationModel(null)
+,_pCurrentSourceForm(SOURCE_FORM_CAMERA)
+, _timeCount(0)
+, _isRecording(false)
+, _isRecordingPause(false)
+, _chargingCount(0)
+, _blinkCount(0)
+, _appControlActionCompleted(false)
+, _isUsedTimerCaptured(false)
+, _closeTimerValue(0)
+,_pAppTimer(null)
+,_pIntervalValueTimer(null)
+,_pCaptureStartTimer(null)
+,_pPopupTimer(null)
+,_pExposureCloseTimer(null)
+,_pTouchAutoFocusTimer(null)
+,_pHelpCloseTimer(null)
+,_pChargingTimer(null)
+,_pChargingCompletedTimer(null)
+,_pPreviewFailPopupTimer(null)
+,_pMakerFocusTimer(null)
{
//empty Implementation
}
void
BaseForm::OnSliderBarMoved (Tizen::Ui::Controls::Slider &source, int value)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
void
BaseForm::OnFileEventOccured (const unsigned long events, const Tizen::Base::String &path, const unsigned int eventId)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
void
BaseForm::OnAdjustmentValueChanged (const Tizen::Ui::Control &source, int adjustment)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
void
BaseForm::OnTouchCanceled (const Tizen::Ui::Control &source, const Tizen::Graphics::Point ¤tPosition, const Tizen::Ui::TouchEventInfo &touchInfo)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
void
void
BaseForm::OnTouchMoved (const Tizen::Ui::Control &source, const Tizen::Graphics::Point ¤tPosition, const Tizen::Ui::TouchEventInfo &touchInfo)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
void
BaseForm::OnTouchPressed (const Tizen::Ui::Control &source, const Tizen::Graphics::Point ¤tPosition, const Tizen::Ui::TouchEventInfo &touchInfo)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
void
BaseForm::OnTouchReleased (const Tizen::Ui::Control &source, const Tizen::Graphics::Point ¤tPosition, const Tizen::Ui::TouchEventInfo &touchInfo)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
void
BaseForm::OnKeyLongPressed (const Tizen::Ui::Control &source, Tizen::Ui::KeyCode keyCode)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
void
BaseForm::OnKeyPressed (const Tizen::Ui::Control &source, Tizen::Ui::KeyCode keyCode)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
void
BaseForm::OnKeyReleased (const Tizen::Ui::Control &source, Tizen::Ui::KeyCode keyCode)
{
- //empty Implementation
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
}
AppLaunchType
AppLogDebug("EXIT - CATCH");
return TYPE_UNDEFINED_CALL;
}
+
+void
+BaseForm::BaseFormOnActionPerformed(const Tizen::Ui::Control& source, int actionId)
+{
+ //empty Implementation
+}
+
+result
+BaseForm::SendAppControlResult(RequestId requestId)
+{
+ AppLogDebug("ENTER");
+ result r = E_SUCCESS;
+ String fullFileName = L"";
+ int storageType = STORAGE_TYPE_PHONE;
+ int mode = CameraPresentationModel::CAMERA_MODE_SNAPSHOT;
+ String filePath = L"";
+ int requestType = 0;
+
+ HashMap* pExtraData = new (std::nothrow) HashMap(SingleObjectDeleter);
+ r = pExtraData->Construct();
+ AppLogDebug("HashMap::Construct() fail[%s]", GetErrorMessage(r));
+
+ if (GetAppLaunchType() == APP_LAUNCH_TYPE_REQUESET)
+ {
+ requestType = _pCameraPresentationModel->GetAppControlRequestType();
+
+ switch (requestType)
+ {
+ case CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_CANCELED:
+ {
+ r = ReturnValues(requestId, APP_CTRL_RESULT_CANCELED, null);
+ TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
+ }
+ break;
+
+ case CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_SUCCEEDED:
+ {
+ r = _pCameraPresentationModel->GetValue(CURRENT_MODE, mode);
+ TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
+
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
+
+ if (storageType == STORAGE_TYPE_PHONE)
+ {
+ r = filePath.Format(MAX_DIRECTORY_PATH_LENGTH, L"%ls%ls", Environment::GetMediaPath().GetPointer(), STRING_CAMERA_FOLDER);
+ TryCatch(r == E_SUCCESS, , "String::Format() fail[%s]", GetErrorMessage(r));
+ }
+ else
+ {
+ r = filePath.Format(MAX_DIRECTORY_PATH_LENGTH, L"%ls%ls", Environment::GetExternalStoragePath().GetPointer(), STRING_CAMERA_FOLDER);
+ TryCatch(r == E_SUCCESS, , "String::Format() fail[%s]", GetErrorMessage(r));
+ }
+ AppLogDebug("FilePath %ls", filePath.GetPointer());
+
+ if (mode == CameraPresentationModel::CAMERA_MODE_SNAPSHOT)
+ {
+ r = _pCameraPresentationModel->GetLatestContentName(CameraPresentationModel::CAMERA_MODE_SNAPSHOT, fullFileName);
+ TryCatch(r == E_SUCCESS, , "pCameraPresentationModel->GetLatestContentName fail[%s]", GetErrorMessage(r));
+ }
+ else
+ {
+ r = _pCameraPresentationModel->GetLatestContentName(CameraPresentationModel::CAMERA_MODE_RECORD, fullFileName);
+ TryCatch(r == E_SUCCESS, , "pCameraPresentationModel->GetLatestContentName fail[%s]", GetErrorMessage(r));
+ }
+
+ AppLogDebug("fullFileName:%ls", fullFileName.GetPointer());
+
+ ArrayList* pPaths = new (std::nothrow) ArrayList();
+ pPaths->Construct();
+ pPaths->Add(new (std::nothrow) String(filePath + fullFileName));
+
+ pExtraData->Add(new (std::nothrow) String(OUTPUT_KEY_RESULT), pPaths);
+
+ r = ReturnValues(requestId, APP_CTRL_RESULT_SUCCEEDED, pExtraData);
+ TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
+ }
+ break;
+
+ case CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED:
+ {
+ r = ReturnValues(requestId, APP_CTRL_RESULT_FAILED, null);
+ TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+ else
+ {
+ AppLogDebug("Not AppControl");
+ r = ReturnValues(requestId, APP_CTRL_RESULT_FAILED, null);
+ TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
+ }
+
+ delete pExtraData;
+ pExtraData = null;
+
+ AppLogDebug("EXIT");
+ return r;
+
+ CATCH:
+ delete pExtraData;
+ pExtraData = null;
+
+ AppLogDebug("EXIT - CATCH");
+ return r;
+}
+
+result
+BaseForm::LaunchAppControl(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::String* pUriData, const Tizen::Base::String* pDataType, const Tizen::Base::Collection::IMap* extraData)
+{
+ AppLogDebug("ENTER");
+ result r = E_SUCCESS;
+ CameraApp* pCameraApp = null;
+ AppControl* pAc = null;
+
+ AppLogDebug("pUriData %ls", pUriData->GetPointer());
+ AppLogDebug("pDataType %ls", pDataType->GetPointer());
+
+#if true
+ pAc = AppManager::FindAppControlN(providerId, operationId);
+ TryCatch(pAc != null, r = E_OBJ_NOT_FOUND, "Failed to find the appcontrol");
+
+ r = pAc->Start(null, pDataType, extraData, null);
+ TryCatch(r == E_SUCCESS, , "[%s] Failed to start the appcontrol", GetErrorMessage(r));
+
+ pCameraApp = static_cast<CameraApp*>(CameraApp::GetInstance());
+ pCameraApp->SetFrameEnabled(false);
+ Invalidate(true);
+
+ delete pAc;
+#else
+ r = AppControl::FindAndStart(operationId, null, pDataType, null, extraData, null);
+ TryCatch(r == E_SUCCESS, , "[%s] Failed to start the appcontrol", GetErrorMessage(r));
+#endif
+ AppLogDebug("EXIT");
+ return r;
+
+ CATCH:
+ if (pAc != null)
+ {
+ delete pAc;
+ }
+ return E_FAILURE;
+}
+
+void
+BaseForm::OnAppControlCompleted(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::Collection::IList* pResultList)
+{
+ AppLogDebug("ENTER");
+ AppLogDebug("EXIT");
+}
+
+void
+BaseForm::SetStorageType(int storageType)
+{
+ AppLogDebug("ENTER");
+ result r = E_SUCCESS;
+
+ if (storageType == STORAGE_TYPE_PHONE)
+ {
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, storageType);
+ TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ }
+ else if (storageType == STORAGE_TYPE_MEMORYCARD)
+ {
+ if (_pCameraPresentationModel->IsStorageCardMounted() == true)
+ {
+ AppLogDebug("StorageCard mount");
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, storageType);
+ TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_MOUNT);
+ }
+ else
+ {
+ AppLogDebug("StorageCard unmount");
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ }
+ }
+ AppLogDebug("EXIT");
+}
+
+void
+BaseForm::ShowCameraFailPopup(void)
+{
+ AppLogDebug("ENTER");
+ int modalResult = 0;
+ MessageBox msgBox;
+ String tmpString = L"";
+ result r = E_SUCCESS;
+ AppResource* pAppResource = null;
+
+ pAppResource = Application::GetInstance()->GetAppResource();
+ TryReturnVoid(pAppResource != null, "Failed to allocate memory for pAppResource");
+
+ pAppResource->GetString(L"IDS_CAM_POP_CAMERA_FAILED", tmpString);
+
+ r = msgBox.Construct(L"", tmpString, MSGBOX_STYLE_NONE, MESSAGEBOX_DISPLAY_TIME_2_SEC);
+ TryReturnVoid(r == E_SUCCESS, "msgBox::Construct() failed by [%s]", GetErrorMessage(r));
+ msgBox.ShowAndWait(modalResult);
+
+ switch (modalResult)
+ {
+ case MSGBOX_RESULT_CLOSE:
+ {
+ _pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
+
+ r = _pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
+ AppLogDebug("SetValue fail [%s]", GetErrorMessage(r));
+
+ r = TerminateApp();
+ AppLogDebug("TerminateApp fail [%s]", GetErrorMessage(r));
+ }
+ break;
+
+ default:
+ break;
+ }
+ AppLogDebug("EXIT");
+}
+
+void
+BaseForm::ShowUnlaunchPopup(void)
+{
+ AppLogDebug("ENTER");
+ int modalResult = 0;
+ MessageBox msgBox;
+ String tmpString;
+ AppResource* pAppResource = null;
+ result r = E_SUCCESS;
+
+ pAppResource = Application::GetInstance()->GetAppResource();
+ TryReturnVoid(pAppResource != null, "Failed to allocate memory for pAppResource");
+
+ pAppResource->GetString(L"IDS_CAM_POP_UNABLE_TO_START_CAMERA_DURING_CALL", tmpString);
+
+ r = msgBox.Construct(L"", tmpString, MSGBOX_STYLE_NONE, MESSAGEBOX_DISPLAY_TIME_3_SEC);
+ TryReturnVoid(r == E_SUCCESS, "msgBox::Construct() failed by [%s]", GetErrorMessage(r));
+ msgBox.ShowAndWait(modalResult);
+
+ _pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
+ r = TerminateApp();
+ AppLogDebug("TerminateApp fail [%s]", GetErrorMessage(r));
+
+ AppLogDebug("EXIT");
+}
+
+void
+BaseForm::ShowLowBatteryPopup(void)
+{
+ AppLogDebug("ENTER");
+ int modalResult = 0;
+ MessageBox msgBox;
+ String tmpString;
+ AppResource* pAppResource = null;
+ result r = E_SUCCESS;
+
+ pAppResource = Application::GetInstance()->GetAppResource();
+ TryReturnVoid(pAppResource != null, "Failed to allocate memory for pAppResource");
+
+ pAppResource->GetString(L"IDS_COM_BODY_LOW_BATTERY", tmpString);
+
+ r = msgBox.Construct(L"", tmpString, MSGBOX_STYLE_NONE, MESSAGEBOX_DISPLAY_TIME_3_SEC);
+ TryReturnVoid(r == E_SUCCESS, "msgBox::Construct() failed by [%s]", GetErrorMessage(r));
+ msgBox.ShowAndWait(modalResult);
+
+ switch (modalResult)
+ {
+ case MSGBOX_RESULT_CLOSE:
+ {
+ AppLogDebug("MSGBOX_RESULT_CLOSE");
+ _pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
+
+ r = TerminateApp();
+ AppLogDebug("TerminateApp fail [%s]", GetErrorMessage(r));
+ }
+ break;
+
+ default:
+ break;
+ }
+ AppLogDebug("EXIT");
+}
+
+result
+BaseForm::TerminateApp(void)
+{
+
+ AppLogDebug("ENTER");
+ result r = E_SUCCESS;
+ CameraApp* pCameraApp = static_cast<CameraApp*>(CameraApp::GetInstance());
+
+ RemoveAllEventListener();
+ _appControlActionCompleted = true;
+ DeleteTimer();
+ _blinkCount = 0;
+
+ if (_pCurrentSourceForm == SOURCE_FORM_CAMERA)
+ {
+ _timeCount = 0;
+ _chargingCount = 0;
+ _isUsedTimerCaptured = false;
+ _closeTimerValue = 0;
+ }
+
+ if (_pCurrentSourceForm == SOURCE_FORM_CAMCORDER)
+ {
+ _isRecording = false;
+ _isRecordingPause = false;
+ }
+
+ _pCameraPresentationModel->StopCamera();
+
+ r = SendAppControlResult(pCameraApp->GetRequestId());
+ TryCatch(r == E_SUCCESS, , "SendAppControlResult fail[%s]", GetErrorMessage(r));
+
+ AppLogDebug("EXIT");
+ return r;
+
+CATCH:
+ AppLogDebug("EXIT - CATCH");
+ return r;
+}
+
+void
+BaseForm::RemoveAllEventListener(void)
+{
+ AppLogDebug("ENTER");
+ RemoveOrientationEventListener(*this);
+ RemoveTouchEventListener(*this);
+ RemoveKeyEventListener(*this);
+ AppLogDebug("EXIT");
+}
+
+void
+BaseForm::DeleteTimer(void)
+{
+ AppLogDebug("ENTER");
+
+ if (_pAppTimer)
+ {
+ _pAppTimer->Cancel();
+ delete _pAppTimer;
+ _pAppTimer = null;
+ }
+
+ if (_pIntervalValueTimer)
+ {
+ _pIntervalValueTimer->Cancel();
+ delete _pIntervalValueTimer;
+ _pIntervalValueTimer = null;
+ }
+
+ if (_pCurrentSourceForm == SOURCE_FORM_CAMERA)
+ {
+ if (_pCaptureStartTimer != null)
+ {
+ _pCaptureStartTimer->Cancel();
+ delete _pCaptureStartTimer;
+ _pCaptureStartTimer = null;
+ }
+
+ if (_pTouchAutoFocusTimer != null)
+ {
+ _pTouchAutoFocusTimer->Cancel();
+ delete _pTouchAutoFocusTimer;
+ _pTouchAutoFocusTimer = null;
+ }
+ }
+
+ if (_pPopupTimer)
+ {
+ _pPopupTimer->Cancel();
+ delete _pPopupTimer;
+ _pPopupTimer = null;
+ }
+
+ if (_pExposureCloseTimer)
+ {
+ _pExposureCloseTimer->Cancel();
+ delete _pExposureCloseTimer;
+ _pExposureCloseTimer = null;
+ }
+
+ if (_pCurrentSourceForm == SOURCE_FORM_CAMCORDER)
+ {
+ if (_pMakerFocusTimer)
+ {
+ _pMakerFocusTimer->Cancel();
+ delete _pMakerFocusTimer;
+ _pMakerFocusTimer = null;
+ }
+ }
+
+ if (_pHelpCloseTimer)
+ {
+ _pHelpCloseTimer->Cancel();
+ delete _pHelpCloseTimer;
+ _pHelpCloseTimer = null;
+ }
+
+ if (_pChargingTimer)
+ {
+ _pChargingTimer->Cancel();
+ delete _pChargingTimer;
+ _pChargingTimer = null;
+ }
+
+ if (_pChargingCompletedTimer != null)
+ {
+ if (_pCurrentSourceForm == SOURCE_FORM_CAMERA)
+ {
+ _pChargingCompletedTimer->Cancel();
+ delete _pChargingCompletedTimer;
+ _pChargingCompletedTimer = null;
+ }
+
+ if (_pCurrentSourceForm == SOURCE_FORM_CAMCORDER)
+ {
+ _chargingCount = 0;
+ _blinkCount = 0;
+ _pChargingCompletedTimer->Cancel();
+ delete _pChargingTimer;
+ _pChargingTimer = null;
+ }
+ }
+
+ if (_pPreviewFailPopupTimer != null)
+ {
+ _pPreviewFailPopupTimer->Cancel();
+ delete _pPreviewFailPopupTimer;
+ _pPreviewFailPopupTimer = null;
+ }
+ AppLogDebug("EXIT");
+}
static const int MENU_TWO_ELEMENT = 2;
static const int MENU_THREE_ELEMENT = 3;
static const int EXPOSURE_TIMER_IS_ALIVE = 1;
-static const int MESSAGEBOX_DISPLAY_TIME_2_SEC = 2000;
-static const int MESSAGEBOX_DISPLAY_TIME_3_SEC = 3000;
static const int MODE_AUTO = 0;
static const int MODE_WHITEBALANCE_INCANDESCENT = 1;
static const int MODE_FLUORESCENT = 2;
};
CamcorderForm::CamcorderForm(void)
- : __pCamcorderPresentationModel(null)
- , __screenMode(SCREEN_MODE_NORMAL)
+ : __screenMode(SCREEN_MODE_NORMAL)
, __pOverlayPanel(null)
- , __pAppTimer(null)
- , __pIntervalValueTimer(null)
, __pRecordTimer(null)
- , __pPopupTimer(null)
- , __pExposureCloseTimer(null)
- , __pMakerFocusTimer(null)
- , __pChargingTimer(null)
- , __pChargingCompletedTimer(null)
- , __pHelpCloseTimer(null)
- , __pPreviewFailPopupTimer(null)
, __pListViewCamcoderTabMainMenu(null)
, __pListViewCamcoderTabSubMenu(null)
, __pListViewGeneralTabMainMenu(null)
, __settingWhiteBalance(0)
, __settingTimeInterval(0)
, __settingExposure(0)
- , __timeCount(0)
+
, __recordTimeCount(0)
, __recordingMaxTime(0)
- , __closeTimerValue(0)
- , __isRecording(false)
- , __isRecordingPause(false)
+ , _closeTimerValue(0)
+
, __previewResolutionWidth(0)
, __previewResolutionHeight(0)
, __pRecordingResolutionWidth(0)
, __isMemoryFull(false)
, __isLockScreenMode(false)
, __isOrientationChanged(false)
- , __chargingCount(0)
- , __blinkCount(0)
, __doRecording(false)
, __batteryStatus(BATTERY_STATE_0)
, __pSettingPanel(null)
, __uri(L"")
, __mime(L"")
, __isCapacityBelow(false)
- , __appControlActionCompleted(false)
+
, __pCancelPopup(null)
, __setTimerInterval(false)
, __pRecordPauseBitmap(null)
Point currentPosition;
String filePath = L"";
- __appControlActionCompleted = false;
+ _appControlActionCompleted = false;
AddKeyEventListener(*this);
SetOrientation(ORIENTATION_AUTOMATIC_FOUR_DIRECTION);
__dir = GetOrientationStatus();
- __pCamcorderPresentationModel->SetOrientation(__dir);
+ _pCameraPresentationModel->SetOrientation(__dir);
InitAppTimer();
InitPreviewFailPopupTimer();
InitSettingTimer();
InitChargingTimer();
InitChargingCompletedTimer();
+ _pCurrentSourceForm = SOURCE_FORM_CAMCORDER;
__pCameraInfoPanel = new (std::nothrow) CameraInfoPanel();
TryCatch(__pCameraInfoPanel != null, r = E_FAILURE, "__pCameraInfoPanel is null");
rectPanel = Rectangle(0, 0, W_FULL_PREVIEW_OVERLAY_LANDSCAPE, X_PREVIEW_OVERLAY_LANDSCAPE);
}
- r = __pCamcorderPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
if (r != E_SUCCESS)
{
storageType = STORAGE_TYPE_PHONE;
}
- if (storageType == STORAGE_TYPE_MEMORYCARD && __pCamcorderPresentationModel->IsStorageCardMounted() == false)
+ if (storageType == STORAGE_TYPE_MEMORYCARD && _pCameraPresentationModel->IsStorageCardMounted() == false)
{
- r = __pCamcorderPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
}
- r = __pCamcorderPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
- r = __pCamcorderPresentationModel->GetValue(TIMER_INTERVAL, timerInterval);
+ r = _pCameraPresentationModel->GetValue(TIMER_INTERVAL, timerInterval);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
r = __pCameraInfoPanel->Initialize(rect);
r = __pFileEventManager->Construct(*this);
TryCatch(r == E_SUCCESS, , "Construct() fail[%s]", GetErrorMessage(r));
- filePath = __pCamcorderPresentationModel->GetfilePath(storageType);
+ filePath = _pCameraPresentationModel->GetfilePath(storageType);
AppLogDebug("filePath %ls", filePath.GetPointer());
if (File::IsFileExist(filePath))
AppLogDebug("ENTER");
result r = E_SUCCESS;
- __pCamcorderPresentationModel->KeepScreenOnState(false, true);
+ _pCameraPresentationModel->KeepScreenOnState(false, true);
- __pCamcorderPresentationModel->RemovePresentationChangedEventListener(null);
+ _pCameraPresentationModel->RemovePresentationChangedEventListener(null);
__pCameraInfoPanel->SetDrawIndicatorStroageInfo(false);
__setTimerInterval = false;
- __pCamcorderPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
__isCapacityBelow = false;
RemoveAllEventListener();
- __pCamcorderPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
- r = __pCamcorderPresentationModel->SetValue(OVERLAY_HELP_ENABLE, SCREEN_OVERLAY_HELP_DISABLE);
+ r = _pCameraPresentationModel->SetValue(OVERLAY_HELP_ENABLE, SCREEN_OVERLAY_HELP_DISABLE);
AppLogDebug("SetValue Reg Fail[%s]", GetErrorMessage(r));
if (__isLockScreenMode)
__screenMode = SCREEN_MODE_NORMAL;
- __pCamcorderPresentationModel = null;
+ _pCameraPresentationModel = null;
__pCameraStarterThread = null;
+ EndRecordTimer();
DeleteTimer();
if (__pRecordPauseBitmap)
{
case SETTING_TIMER_RECORD_0_SEC:
{
- if (__pIntervalValueTimer)
+ if (_pIntervalValueTimer)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
- __isRecording = true;
+ _isRecording = true;
__setTimerInterval = false;
- __pCamcorderPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
- __pCamcorderPresentationModel->StartRecord();
+ _pCameraPresentationModel->StartRecord();
r = StartRecordTimer();
TryReturnVoid(r == E_SUCCESS, "StartRecordTimer() fail[%s]", GetErrorMessage(r));
TryReturnVoid(r == E_SUCCESS, "SetRecordStartTimer() fail[%s]", GetErrorMessage(r));
__setTimerInterval = true;
- __pCamcorderPresentationModel->SetIntervalTimerRun(true);
+ _pCameraPresentationModel->SetIntervalTimerRun(true);
- __timeCount = 0;
+ _timeCount = 0;
r = DrawTimerPopup();
TryReturnVoid(r == E_SUCCESS, "DrawTimerPopup() fail[%s]", GetErrorMessage(r));
bool isCharging = false;
BatteryLevel batteryLevel;
- batteryLevel = __pCamcorderPresentationModel->GetBatteryLevel();
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
if (r != E_SUCCESS)
{
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
ShowUiQuickMenu();
}
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
HideUiQuickMenu();
}
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
MakeCamcoderTabSettingPopup();
}
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
if (__pListViewGeneralTabMainMenu)
{
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
AppLogDebug("IDA_BUTTON_SETTING_GENERAL");
result r = E_SUCCESS;
int cameraCount = 0;
- if (__pCamcorderPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW)
+ if (_pCameraPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW)
{
AppLogDebug("Camera Preview is not");
return;
}
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_COUNT, cameraCount);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_COUNT, cameraCount);
AppLogDebug("GetMediaCapability [%s]", GetErrorMessage(r));
if (cameraCount < SUPPORTED_CAMERA_NUM)
{
return;
}
- onVideoRecorderStopped = __pCamcorderPresentationModel->GetOnVideoRecorderStopped();
+ onVideoRecorderStopped = _pCameraPresentationModel->GetOnVideoRecorderStopped();
MakeSettingPopupTab(false);
result r = E_SUCCESS;
int selfPortraitEnable = 0;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
if (__pCameraInfoPanel->GetDrawExposure() == true)
{
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
__pCameraInfoPanel->SetDrawExposure(false);
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
}
if (r == E_SUCCESS)
result r = E_SUCCESS;
AppLogDebug("IDA_BUTTON_RECORDING_POPUP_OK");
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
TryReturnVoid(r == E_SUCCESS, "Timer::Start() fail[%s]", GetErrorMessage(r));
if (__pCancelPopup)
__pCancelPopup->Invalidate(true);
}
- __isRecording = true;
+ _isRecording = true;
- __pCamcorderPresentationModel->SetCancelRecord(false);
+ _pCameraPresentationModel->SetCancelRecord(false);
r = SetRecordPauseBitmap(false);
//TryCatch(r == E_SUCCESS, , "SetRecordPauseBitmap start fail[%s]", GetErrorMessage(r));
r = SetRecordPauseButton(false);
TryReturnVoid(r == E_SUCCESS, "SetRecordPauseButton fail[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->StartRecord();
+ _pCameraPresentationModel->StartRecord();
__pRecordTimer->StartAsRepeatable(CAMCORDER_TIMER_ONE_SEC);
}
{
__pResetPopUp->SetShowState(false);
}
- r = __pCamcorderPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
TryReturnVoid(r == E_SUCCESS, "GetValue() fail(%s)", GetErrorMessage(r));
if (guideLineEnable == CAMERA_GUIDELINE_ENABLE)
SetGuideLine(REG_DEFAULT_VALUE_ZERO);
}
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "GetValue() fail(%s)", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
AppLogDebug("SUBMENU_RESET_MODE : CAMERA_FORM_SECONDARY_MODE");
- r = __pCamcorderPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
+ r = _pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
TryReturnVoid(r == E_SUCCESS, "SetValue() fail(%s)", GetErrorMessage(r));
r = ToggleCameraDirection(CAMCORDER_FORM_PRIMARY_MODE);
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "__pOverlayPanel->GetBackgroundBufferInfo() fail(%s)", GetErrorMessage(r));
- __pCamcorderPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCamcorderPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
}
RestoreDefaultSetting();
- r = __pCamcorderPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_RECORD);
+ r = _pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_RECORD);
TryReturnVoid(r == E_SUCCESS, "Reg setValue fail[%s]", GetErrorMessage(r));
MakeRecordingResolutionList(true);
AppLogDebug("EXIT");
}
-result
-CamcorderForm::SendAppControlResult(RequestId requestId)
-{
- AppLogDebug("ENTER");
- result r = E_SUCCESS;
- String fullFileName = L"";
- int storageType = STORAGE_TYPE_PHONE;
- int mode = CameraPresentationModel::CAMERA_MODE_SNAPSHOT;
- String filePath = L"";
- int requestType = 0;
-
- HashMap* pExtraData = new (std::nothrow) HashMap(SingleObjectDeleter);
- r = pExtraData->Construct();
- AppLogDebug("HashMap::Construct() fail[%s]", GetErrorMessage(r));
-
- if (GetAppLaunchType() == APP_LAUNCH_TYPE_REQUESET)
- {
- requestType = __pCamcorderPresentationModel->GetAppControlRequestType();
-
- switch (requestType)
- {
- case CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_CANCELED:
- {
- r = ReturnValues(requestId, APP_CTRL_RESULT_CANCELED, null);
- TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
- }
- break;
-
- case CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_SUCCEEDED:
- {
- r = __pCamcorderPresentationModel->GetValue(CURRENT_MODE, mode);
- TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
-
- r = __pCamcorderPresentationModel->GetValue(STORAGE_TYPE, storageType);
- TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
-
- if (storageType == STORAGE_TYPE_PHONE)
- {
- r = filePath.Format(MAX_DIRECTORY_PATH_LENGTH, L"%ls%ls", Environment::GetMediaPath().GetPointer(), STRING_CAMERA_FOLDER);
- TryCatch(r == E_SUCCESS, , "String::Format() fail[%s]", GetErrorMessage(r));
- }
- else
- {
- r = filePath.Format(MAX_DIRECTORY_PATH_LENGTH, L"%ls%ls", Environment::GetExternalStoragePath().GetPointer(), STRING_CAMERA_FOLDER);
- TryCatch(r == E_SUCCESS, , "String::Format() fail[%s]", GetErrorMessage(r));
- }
- AppLogDebug("FilePath %ls", filePath.GetPointer());
-
- if (mode == CameraPresentationModel::CAMERA_MODE_SNAPSHOT)
- {
- r = __pCamcorderPresentationModel->GetLatestContentName(CameraPresentationModel::CAMERA_MODE_SNAPSHOT, fullFileName);
- TryCatch(r == E_SUCCESS, , "pCameraPresentationModel->GetLatestContentName fail[%s]", GetErrorMessage(r));
- }
- else
- {
- r = __pCamcorderPresentationModel->GetLatestContentName(CameraPresentationModel::CAMERA_MODE_RECORD, fullFileName);
- TryCatch(r == E_SUCCESS, , "pCameraPresentationModel->GetLatestContentName fail[%s]", GetErrorMessage(r));
- }
-
- AppLogDebug("fullFileName:%ls", fullFileName.GetPointer());
-
- ArrayList* pPaths = new (std::nothrow) ArrayList();
- pPaths->Construct();
- pPaths->Add(new (std::nothrow) String(filePath + fullFileName));
-
- pExtraData->Add(new (std::nothrow) String(OUTPUT_KEY_RESULT), pPaths);
-
- r = ReturnValues(requestId, APP_CTRL_RESULT_SUCCEEDED, pExtraData);
- TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
- }
- break;
-
- case CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED:
- {
- r = ReturnValues(requestId, APP_CTRL_RESULT_FAILED, null);
- TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
- }
- break;
-
- default:
- break;
- }
- }
- else
- {
- AppLogDebug("Not AppControl");
- r = ReturnValues(requestId, APP_CTRL_RESULT_FAILED, null);
- TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
- }
-
- delete pExtraData;
- pExtraData = null;
-
- AppLogDebug("EXIT");
- return r;
-
-CATCH:
- delete pExtraData;
- pExtraData = null;
-
- AppLogDebug("EXIT - CATCH");
- return r;
-}
-
-result
-CamcorderForm::TerminateApp(void)
-{
- AppLogDebug("ENTER");
- result r = E_SUCCESS;
- CameraApp* pCameraApp = static_cast<CameraApp*>(CameraApp::GetInstance());
-
- __appControlActionCompleted = true;
-
- RemoveAllEventListener();
-
- DeleteTimer();
-
- __blinkCount = 0;
-
- __isRecording = false;
-
- __isRecordingPause = false;
-
- __pCamcorderPresentationModel->StopCamera();
-
- r = SendAppControlResult(pCameraApp->GetRequestId());
- TryCatch(r == E_SUCCESS, , "SendAppControlResult fail[%s]", GetErrorMessage(r));
-
- AppLogDebug("EXIT");
- return r;
-
-CATCH:
- AppLogDebug("EXIT - CATCH");
- return r;
-}
-
void
CamcorderForm::OnFormBackRequested(Tizen::Ui::Controls::Form& source)
{
result r = E_SUCCESS;
CameraApp* pCameraApp = static_cast<CameraApp*>(CameraApp::GetInstance());
+ EndRecordTimer();
DeleteTimer();
- __blinkCount = 0;
+ _blinkCount = 0;
- __isRecording = false;
+ _isRecording = false;
- __pCamcorderPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
r = SendAppControlResult(pCameraApp->GetRequestId());
TryReturnVoid(r == E_SUCCESS, "SendAppControlResult [%s]", GetErrorMessage(r));
return __mime;
}
-result
-CamcorderForm::LaunchAppControl(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::String* pUriData, const Tizen::Base::String* pDataType, const Tizen::Base::Collection::IMap* extraData)
-{
- AppLogDebug("ENTER");
- result r = E_SUCCESS;
- CameraApp* pCameraApp = null;
- AppControl* pAc = null;
-
- AppLogDebug("pUriData %ls", pUriData->GetPointer());
- AppLogDebug("pDataType %ls", pDataType->GetPointer());
-
-#if true
- pAc = AppManager::FindAppControlN(providerId, operationId);
- TryCatch(pAc != null, r = E_OBJ_NOT_FOUND, "Failed to find the appcontrol");
-
- r = pAc->Start(null, pDataType, extraData, null);
- TryCatch(r == E_SUCCESS, , "[%s] Failed to start the appcontrol", GetErrorMessage(r));
-
- pCameraApp = static_cast<CameraApp*>(CameraApp::GetInstance());
- pCameraApp->SetFrameEnabled(false);
- Invalidate(true);
-
- delete pAc;
-#else
- r = AppControl::FindAndStart(operationId, null, pDataType, null, extraData, null);
- TryCatch(r == E_SUCCESS, , "[%s] Failed to start the appcontrol", GetErrorMessage(r));
-#endif
- AppLogDebug("EXIT");
- return r;
-
-CATCH:
- if (pAc != null)
- {
- delete pAc;
- }
- return E_FAILURE;
-}
-
-void
-CamcorderForm::OnAppControlCompleted(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::Collection::IList* pResultList)
-{
- AppLogDebug("ENTER");
- AppLogDebug("EXIT");
-}
-
void
CamcorderForm::OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs)
{
AppLogDebug("ENTER");
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("EXIT - App Terminate");
return;
Bitmap* pBitmap = null;
Point ptThumbnailImg = Point(X_THUMBNAIL_BUTTON_IMG, Y_THUMBNAIL_BUTTON_IMG);
- isExistThumbnail = __pCamcorderPresentationModel->IsExistThumbnail(CameraPresentationModel::CAMERA_MODE_RECORD);
+ isExistThumbnail = _pCameraPresentationModel->IsExistThumbnail(CameraPresentationModel::CAMERA_MODE_RECORD);
if (isExistThumbnail == false)
{
bool isCharging = false;
BatteryLevel batteryLevel;
- __isRecording = false;
+ _isRecording = false;
- __isRecordingPause = false;
+ _isRecordingPause = false;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
TryReturnVoid(r == E_SUCCESS, "Timer::Start() fail[%s]", GetErrorMessage(r));
__batteryStatus = GetCurrentBatteryState();
StartInitChargingTimer();
- __pCamcorderPresentationModel->AddPresentationChangedEventListener(*this);
+ _pCameraPresentationModel->AddPresentationChangedEventListener(*this);
- __pCamcorderPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
- r = __pCamcorderPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_RECORD);
+ r = _pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_RECORD);
TryReturnVoid(r == E_SUCCESS, "SetMode() failed:%s", GetErrorMessage(r));
Update(false);
- dim = __pCamcorderPresentationModel->GetPreviewResolution();
+ dim = _pCameraPresentationModel->GetPreviewResolution();
AppLogDebug("CamcorderForm::GetPreviewResolution(W:%d, H:%d)", dim.width, dim.height);
__previewResolutionWidth = dim.width;
__previewResolutionHeight = dim.height;
- dim = __pCamcorderPresentationModel->GetRecordingResolution();
+ dim = _pCameraPresentationModel->GetRecordingResolution();
AppLogDebug("CamcorderForm::GetPreviewResolution(W:%d, H:%d)", dim.width, dim.height);
__pRecordingResolutionWidth = dim.width;
r = SetRecordButton(false);
AppLogDebug("SetRecordButton fail[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_RECORD);
+ _pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_RECORD);
- r = __pCamcorderPresentationModel->GetValue(GUIDELINE_ENABLE, regVal);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, regVal);
TryReturnVoid(r == E_SUCCESS, "Read Reg fail[%s]", GetErrorMessage(r));
if (regVal == DISABLE_GUIDELINE)
__pRecLabelText->Invalidate(true);
}
- isInitCameraStaus = __pCamcorderPresentationModel->GetInitCameraStatus();
+ isInitCameraStaus = _pCameraPresentationModel->GetInitCameraStatus();
AppLogDebug("isInitCameraStaus [%d]", isInitCameraStaus);
if (isInitCameraStaus)
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "GetBackgroundBufferInfo fail[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
}
- __pCamcorderPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
previewResolutionSize = __previewResolutionWidth * __previewResolutionHeight;
AppLogDebug("OnSceneActivatedN");
}
- batteryLevel = __pCamcorderPresentationModel->GetBatteryLevel();
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
if (batteryLevel == BATTERY_CRITICAL || batteryLevel == BATTERY_EMPTY)
CheckCallStatus();
- __pCamcorderPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
- if (storageType == STORAGE_TYPE_MEMORYCARD && __pCamcorderPresentationModel->IsStorageCardMounted() == false)
+ if (storageType == STORAGE_TYPE_MEMORYCARD && _pCameraPresentationModel->IsStorageCardMounted() == false)
{
- r = __pCamcorderPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
- __pCamcorderPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
}
AppLogDebug("EXIT");
}
CamcorderForm::OnSceneDeactivated(const Tizen::Ui::Scenes::SceneId& currentSceneId, const Tizen::Ui::Scenes::SceneId& nextSceneId)
{
AppLogDebug("ENTER");
- __pCamcorderPresentationModel->KeepScreenOnState(false, true);
+ _pCameraPresentationModel->KeepScreenOnState(false, true);
- __isRecording = false;
+ _isRecording = false;
- __isRecordingPause = false;
+ _isRecordingPause = false;
__isOrientationChanged = false;
- __timeCount = 0;
+ _timeCount = 0;
__setTimerInterval = false;
- __pCamcorderPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
- __chargingCount = 0;
+ _chargingCount = 0;
- if (__pAppTimer)
+ if (_pAppTimer)
{
- __pAppTimer->Cancel();
+ _pAppTimer->Cancel();
}
- if (__pIntervalValueTimer)
+ if (_pIntervalValueTimer)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
- if (__pChargingTimer)
+ if (_pChargingTimer)
{
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
}
- if (__pHelpCloseTimer)
+ if (_pHelpCloseTimer)
{
- __pHelpCloseTimer->Cancel();
+ _pHelpCloseTimer->Cancel();
}
EndRecordTimer();
if (GetAppLaunchType() != APP_LAUNCH_TYPE_REQUESET)
{
- if (__doRecording || __isRecording || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ if (__doRecording || _isRecording || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
{
if (__pSwButton)
{
TryCatch(__pThumbnailPanel != null, , "__pThumbnailPanel is null");
- pThumbnailBitmap = __pCamcorderPresentationModel->GetLatestThumbnail();
+ pThumbnailBitmap = _pCameraPresentationModel->GetLatestThumbnail();
if (pThumbnailBitmap == null)
{
AppLogDebug("CameraForm::Update :: pThumbnailBitmap = null");
- if (__isRecording || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ if (_isRecording || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
{
__pThumbnailButton->SetShowState(false);
__pThumbnailPanel->SetShowState(false);
AppLogDebug("CameraForm::Update :: pThumbnailBitmap is not null");
ImageRotationType rotationType = IMAGE_ROTATION_0;
- if (__setTimerInterval || __isRecording || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ if (__setTimerInterval || _isRecording || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
{
__pThumbnailButton->SetShowState(false);
__pThumbnailPanel->SetShowState(false);
Bitmap* pRotateBitmap = null;
ImageRotationType rotationType = IMAGE_ROTATION_0;
- pThumbnailBitmap = __pCamcorderPresentationModel->GetLatestThumbnail();
+ pThumbnailBitmap = _pCameraPresentationModel->GetLatestThumbnail();
TryCatch(pThumbnailBitmap != null, , "pThumbnailBitmap is null");
if (__dir == ORIENTATION_STATUS_PORTRAIT_REVERSE
{
AppLogDebug("ENTER");
- __timeCount = 0;
+ _timeCount = 0;
__doRecording = false;
- if (__pIntervalValueTimer)
+ if (_pIntervalValueTimer)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __pPopupTimer->Cancel();
+ _pPopupTimer->Cancel();
}
if (__pCameraInfoPanel->GetDrawPopupTimer() == true)
case CAMERA_ACTION_EVENT_AUTO_FOCUSED:
{
AppLogDebug("CAMERA_ACTION_EVENT_AUTO_FOCUSED");
- if (__pCamcorderPresentationModel->GetRecorderState() != RECORDER_STATE_RECORDING)
+ if (_pCameraPresentationModel->GetRecorderState() != RECORDER_STATE_RECORDING)
{
AppLogDebug("CAMERA_ACTION_EVENT_AUTO_FOCUSED : NOT STATE_RECORDING");
DrawFocus(CAMERA_FOCUS_READY);
DrawFocus(CAMERA_FOCUS_READY);
InitMakerFocusTimer();
- __pMakerFocusTimer->Cancel();
- __pMakerFocusTimer->Start(CAMCORDER_TIMER_ONE_SEC);
+ _pMakerFocusTimer->Cancel();
+ _pMakerFocusTimer->Start(CAMCORDER_TIMER_ONE_SEC);
}
}
break;
AppLogDebug("VIDEO_RECORDER_CANCELED_LISTENER.");
StartInitAppTimer();
- __isRecording = false;
+ _isRecording = false;
__doRecording = false;
}
break;
bool isCharging = false;
BatteryLevel batteryLevel;
- requestType = __pCamcorderPresentationModel->GetAppControlRequestType();
+ requestType = _pCameraPresentationModel->GetAppControlRequestType();
HideRecLabe();
HideUiPanel(false);
- __pCamcorderPresentationModel->SetOnVideoRecorderStopped(false);
+ _pCameraPresentationModel->SetOnVideoRecorderStopped(false);
- __pCamcorderPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_RECORD);
+ _pCameraPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_RECORD);
if (GetAppLaunchType() == APP_LAUNCH_TYPE_REQUESET && requestType == CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_SUCCEEDED)
{
Update(false);
}
- batteryLevel = __pCamcorderPresentationModel->GetBatteryLevel();
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
AppLogDebug("isCharging = %d", isCharging);
}
}
- AppLogDebug("GetCameraState : %ld", __pCamcorderPresentationModel->GetCameraState());
+ AppLogDebug("GetCameraState : %ld", _pCameraPresentationModel->GetCameraState());
- if (__pCamcorderPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW)
+ if (_pCameraPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW)
{
ReInitialise();
if (UiApp::GetInstance()->GetAppUiState()== APP_UI_STATE_FOREGROUND)
{
- __pCamcorderPresentationModel->SetStartPreviewException(false);
+ _pCameraPresentationModel->SetStartPreviewException(false);
}
}
int requestType = 0;
result r = E_SUCCESS;
- requestType = __pCamcorderPresentationModel->GetAppControlRequestType();
+ requestType = _pCameraPresentationModel->GetAppControlRequestType();
HideRecLabe();
HideUiPanel(false);
- __pCamcorderPresentationModel->SetOnVideoRecorderStopped(false);
+ _pCameraPresentationModel->SetOnVideoRecorderStopped(false);
if (GetAppLaunchType() == APP_LAUNCH_TYPE_REQUESET && requestType == CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_SUCCEEDED)
{
__pBatteryState->Show();
}
- AppLogDebug("Camcorder State = %d ", __pCamcorderPresentationModel->GetRecorderState());
- AppLogDebug("Camera State = %d ", __pCamcorderPresentationModel->GetCameraState());
+ AppLogDebug("Camcorder State = %d ", _pCameraPresentationModel->GetRecorderState());
+ AppLogDebug("Camera State = %d ", _pCameraPresentationModel->GetCameraState());
- if (__pCamcorderPresentationModel->GetCameraState() == CAMERA_STATE_ERROR)
+ if (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_ERROR)
{
- if (__pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_INITIALIZED)
+ if (_pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_INITIALIZED)
{
ReInitialise();
}
pCameraApp->SetFrameEnabled(true);
}
- isInitCameraStaus = __pCamcorderPresentationModel->GetInitCameraStatus();
+ isInitCameraStaus = _pCameraPresentationModel->GetInitCameraStatus();
AppLogDebug("isInitCameraStaus = %d", isInitCameraStaus);
if (isInitCameraStaus == false)
__pCancelPopup = null;
}
- __pCamcorderPresentationModel->SetOnVideoRecorderStopped(false);
+ _pCameraPresentationModel->SetOnVideoRecorderStopped(false);
- if (__pCamcorderPresentationModel->IsCameraPoweredOn())
+ if (_pCameraPresentationModel->IsCameraPoweredOn())
{
AppLogDebug("CAMERA_ACTION_EVENT_FRAME_ACTIVATED && CameraPoweredOn");
}
- if (__pCamcorderPresentationModel->GetCameraState() == CAMERA_STATE_ERROR)
+ if (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_ERROR)
{
- if (__pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_INITIALIZED)
+ if (_pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_INITIALIZED)
{
ReInitialise();
}
}
- if (__pCamcorderPresentationModel->GetStartPreviewException() &&
- __pCamcorderPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW )
+ if (_pCameraPresentationModel->GetStartPreviewException() &&
+ _pCameraPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW )
{
ReInitialise();
- __pCamcorderPresentationModel->SetStartPreviewException(false);
+ _pCameraPresentationModel->SetStartPreviewException(false);
}
- batteryLevel = __pCamcorderPresentationModel->GetBatteryLevel();
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
if (batteryLevel == BATTERY_CRITICAL || batteryLevel == BATTERY_EMPTY)
GetCameraToForeground();
}
- batteryLevel = __pCamcorderPresentationModel->GetBatteryLevel();
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
if (batteryLevel == BATTERY_CRITICAL || batteryLevel == BATTERY_EMPTY)
AppLogDebug("CAMERA_ACTION_EVENT_FRAME_DEACTIVATED");
bool isInitCameraStaus = false;
- isInitCameraStaus = __pCamcorderPresentationModel->GetInitCameraStatus();
+ isInitCameraStaus = _pCameraPresentationModel->GetInitCameraStatus();
AppLogDebug("isInitCameraStaus = %d", isInitCameraStaus);
if (isInitCameraStaus == false)
return;
}
- __pCamcorderPresentationModel->SetOnVideoRecorderStopped(false);
+ _pCameraPresentationModel->SetOnVideoRecorderStopped(false);
if (__pCancelPopup != null)
{
return;
}
- if (__pCamcorderPresentationModel->GetStartPreviewException())
+ if (_pCameraPresentationModel->GetStartPreviewException())
{
ShowCameraFailPopup();
}
BatteryLevel batteryLevel;
result r = E_SUCCESS;
- batteryLevel = __pCamcorderPresentationModel->GetBatteryLevel();
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
AppLogDebug("isCharging = %d", isCharging);
{
if (batteryLevel == BATTERY_CRITICAL || batteryLevel == BATTERY_EMPTY)
{
- __pCamcorderPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
+ _pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
- __pCamcorderPresentationModel->SetOnVideoRecorderStopped(false);
+ _pCameraPresentationModel->SetOnVideoRecorderStopped(false);
- if (__pCamcorderPresentationModel->GetRecorderState()== RECORDER_STATE_RECORDING
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED
+ if (_pCameraPresentationModel->GetRecorderState()== RECORDER_STATE_RECORDING
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED
)
{
- AppLogDebug("StopRecord::GetRecorderState() = %d", __pCamcorderPresentationModel->GetRecorderState());
+ AppLogDebug("StopRecord::GetRecorderState() = %d", _pCameraPresentationModel->GetRecorderState());
- __pCamcorderPresentationModel->StopRecord();
- __pCamcorderPresentationModel->UpdateContentFile();
+ _pCameraPresentationModel->StopRecord();
+ _pCameraPresentationModel->UpdateContentFile();
r = TerminateApp();
}
else
int requestType = 0;
result r = E_SUCCESS;
- requestType = __pCamcorderPresentationModel->GetAppControlRequestType();
+ requestType = _pCameraPresentationModel->GetAppControlRequestType();
+ if (__pCancelPopup != null)
+ {
+ delete __pCancelPopup;
+ __pCancelPopup = null;
+ _pCameraPresentationModel->SetCancelRecord(true);
+ if (_pAppTimer)
+ {
+ _pAppTimer->Cancel();
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ }
+
+ HideRecLabe();
+ HideUiPanel(false);
+ CancelRecord();
+ }
+
if (GetAppLaunchType() == APP_LAUNCH_TYPE_REQUESET && requestType == CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED)
{
AppLogDebug("Camera Captured after TerminateApp");
}
else
{
- if (__isRecording || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ AppLogDebug("recorderstate is %d",_pCameraPresentationModel->GetRecorderState());
+ AppLogDebug("_isRecording is %d",_isRecording);
+ if (_isRecording || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_STOPPING)
{
HideUiAction();
- AppLogDebug("__isRecording");
+ AppLogDebug("_isRecording");
__doRecording = false;
- __isRecordingPause = false;
+ _isRecordingPause = false;
__setTimerInterval = false;
- __pCamcorderPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
StopRecord();
r = UpdateUiPanelIcon();
//TryCatch(r == E_SUCCESS, r = E_SYSTEM, "UpdateUiPanelIcon() fail[%s]", GetErrorMessage(r));
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_COUNT, cameraCount);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_COUNT, cameraCount);
AppLogDebug("GetMediaCapability [%s]", GetErrorMessage(r));
if (cameraCount > SUPPORTED_CAMERA_NUM)
{
bool value = false;
ImageRotationType rotationType = IMAGE_ROTATION_0;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue Reg Fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
{
- r = __pCamcorderPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
TryCatch(r == E_SUCCESS, , "SetValue Reg Fail[%s]", GetErrorMessage(r));
pBitmap = ResourceManager::GetBitmapN(RESOURCE_ID_CAMERA_MODE_FLASH_OFF_PRESS_DIM);
}
else if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
+ r = _pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
TryCatch(r == E_SUCCESS, , "Read Reg Fail[%s]", GetErrorMessage(r));
switch (flashMode)
}
else
{
- r = __pCamcorderPresentationModel->SetValue(FLASH_MODE_PRIMARY, FLASH_MODE_OFF);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, FLASH_MODE_OFF);
TryCatch(r == E_SUCCESS, , "SetValue Reg Fail[%s]", GetErrorMessage(r));
pBitmap = ResourceManager::GetBitmapN(RESOURCE_ID_CAMERA_MODE_FLASH_OFF_PRESS_DIM);
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
}
if (r == E_SUCCESS)
result r = E_SUCCESS;
String controlName = "L";
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("OnTouchPressed >> TerminateApp Execution");
return;
if (__pCameraInfoPanel->GetDrawExposure() == true)
{
- TryReturnVoid(__pExposureCloseTimer != null, "__pExposureCloseTimer is null");
- __pExposureCloseTimer->Cancel();
+ TryReturnVoid(_pExposureCloseTimer != null, "_pExposureCloseTimer is null");
+ _pExposureCloseTimer->Cancel();
- r = __pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
- TryReturnVoid(r == E_SUCCESS, "__pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
+ r = _pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
+ TryReturnVoid(r == E_SUCCESS, "_pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
}
AppLogDebug("EXIT");
}
bool onVideoRecorderStopped = false;
result r = E_SUCCESS;
- if (__pCamcorderPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW)
+ if (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW)
{
- if (__pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ if (_pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
{
AppLogDebug("Return Camera transform");
return;
}
else
{
- onVideoRecorderStopped = __pCamcorderPresentationModel->GetOnVideoRecorderStopped();
+ onVideoRecorderStopped = _pCameraPresentationModel->GetOnVideoRecorderStopped();
AppLogDebug("pSceneManager->GoForward : onVideoRecorderStopped = %d", onVideoRecorderStopped);
if (onVideoRecorderStopped == false)
AppLogDebug("IDA_BUTTON_CAMCORDER_MODE");
- r = __pCamcorderPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ r = _pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
TryReturnVoid(r == E_SUCCESS, "Reg setvalue fail[%s]", GetErrorMessage(r));
EndRecordTimer();
|| __dir == ORIENTATION_STATUS_PORTRAIT_REVERSE)
{
r = DrawExposureSlider(currentPosition, DRAW_RELEASED);
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- TryReturnVoid(__pExposureCloseTimer != null, "__pExposureCloseTimer is null");
- __pExposureCloseTimer->Cancel();
+ TryReturnVoid(_pExposureCloseTimer != null, "_pExposureCloseTimer is null");
+ _pExposureCloseTimer->Cancel();
- r = __pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
- TryReturnVoid(r == E_SUCCESS, "__pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
+ r = _pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
+ TryReturnVoid(r == E_SUCCESS, "_pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
}
else
{
r = DrawExposureSlider(currentPosition, DRAW_RELEASED);
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- TryReturnVoid(__pExposureCloseTimer != null, "__pExposureCloseTimer is null");
- __pExposureCloseTimer->Cancel();
+ TryReturnVoid(_pExposureCloseTimer != null, "_pExposureCloseTimer is null");
+ _pExposureCloseTimer->Cancel();
- r = __pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
- TryReturnVoid(r == E_SUCCESS, "__pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
+ r = _pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
+ TryReturnVoid(r == E_SUCCESS, "_pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
}
AppLogDebug("EXIT");
}
HideUiAction();
- __pCamcorderPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
- AppLogDebug("Camcorder State = %d ", __pCamcorderPresentationModel->GetRecorderState());
+ AppLogDebug("Camcorder State = %d ", _pCameraPresentationModel->GetRecorderState());
- if (__pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_INITIALIZED
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_OPENED
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_CLOSED
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_STOPPED
+ if (_pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_INITIALIZED
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_OPENED
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_CLOSED
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_STOPPED
)
{
- __pCamcorderPresentationModel->SetFocusMode(CAMERA_FOCUS_MODE_NONE);
+ _pCameraPresentationModel->SetFocusMode(CAMERA_FOCUS_MODE_NONE);
- if (__pChargingTimer)
+ if (_pChargingTimer)
{
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
}
__doRecording = true;
- __isRecordingPause = false;
+ _isRecordingPause = false;
__pBatteryState->SetShowState(false);
__pBatteryState->Draw();
HidePopup();
- onVideoRecorderStopped = __pCamcorderPresentationModel->GetOnVideoRecorderStopped();
+ onVideoRecorderStopped = _pCameraPresentationModel->GetOnVideoRecorderStopped();
if (onVideoRecorderStopped == false)
{
}
else
{
- onVideoRecorderStopped = __pCamcorderPresentationModel->GetOnVideoRecorderStopped();
+ onVideoRecorderStopped = _pCameraPresentationModel->GetOnVideoRecorderStopped();
if (onVideoRecorderStopped == true)
{
AppLogDebug("ENTER");
HideUiAction();
- __pCamcorderPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
__doRecording = false;
- __isRecordingPause = false;
+ _isRecordingPause = false;
__setTimerInterval = false;
- __pCamcorderPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
HideRecLabe();
StartInitChargingTimer();
- __pCamcorderPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
AppLogDebug("EXIT");
}
int storageCardChageState = CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN;
String fullFileName = L"";
- if (__pCamcorderPresentationModel->GetLatestThumbnail() != null)
+ if (_pCameraPresentationModel->GetLatestThumbnail() != null)
{
- onVideoRecorderStopped = __pCamcorderPresentationModel->GetOnVideoRecorderStopped();
+ onVideoRecorderStopped = _pCameraPresentationModel->GetOnVideoRecorderStopped();
- storageCardChageState = __pCamcorderPresentationModel->GetStorageCardChageState();
+ storageCardChageState = _pCameraPresentationModel->GetStorageCardChageState();
if (storageCardChageState == CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_MOUNT_TO_UNMOUNT)
{
AppLogDebug("MOUNT_TO_UNMOUNT : Don't LaunchImageview");
- __pCamcorderPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
if (onVideoRecorderStopped == false)
{
- fullFileName = __pCamcorderPresentationModel->GetContentFilePath(CameraPresentationModel::CAMERA_MODE_RECORD);
+ fullFileName = _pCameraPresentationModel->GetContentFilePath(CameraPresentationModel::CAMERA_MODE_RECORD);
if (fullFileName == L"")
{
else
{
AppLogDebug("LaunchImageview");
- __pCamcorderPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
if (onVideoRecorderStopped == false)
{
- fullFileName = __pCamcorderPresentationModel->GetContentFilePath(CameraPresentationModel::CAMERA_MODE_RECORD);
+ fullFileName = _pCameraPresentationModel->GetContentFilePath(CameraPresentationModel::CAMERA_MODE_RECORD);
if (fullFileName == L"")
{
int checkActivePanel = -1;
bool doHidePopup = false;
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("OnTouchReleased >> TerminateApp Execution");
return;
{
if (source.Equals(*__pRecordButton) == true)
{
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
__pCameraInfoPanel->SetDrawExposure(false);
if ((doHidePopup == false) && (__pCameraInfoPanel->GetDrawExposure() == false))
{
- if ((controlName.Equals(String(IDS_CAMERA_INFO_PANEL_NAME))) && (__pCamcorderPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW))
+ if ((controlName.Equals(String(IDS_CAMERA_INFO_PANEL_NAME))) && (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW))
{
DrawTouchAutoFocus(currentPosition);
}
if ((controlName.Equals(String(IDS_RECORDE_BUTTON_NAME)))&&(source.Equals(*__pRecordButton) == true))
{
- AppLogDebug("Camera State = %d ", __pCamcorderPresentationModel->GetCameraState());
+ AppLogDebug("Camera State = %d ", _pCameraPresentationModel->GetCameraState());
- if (__isRecording == false)
+ if (_isRecording == false)
{
- if (__pCamcorderPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW
- && __pCamcorderPresentationModel->GetCameraState() != CAMERA_STATE_AUTO_FOCUSING
+ if (_pCameraPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW
+ && _pCameraPresentationModel->GetCameraState() != CAMERA_STATE_AUTO_FOCUSING
)
{
AppLogDebug("It is trying to start the recording ");
if (controlName.Equals(String(IDS_THUMBNAIL_PANLE_NAME))
&& __pThumbnailPanel->GetShowState() == true
&& (GetAppLaunchType() != APP_LAUNCH_TYPE_REQUESET)
- && __pCamcorderPresentationModel->GetRecorderState() != RECORDER_STATE_RECORDING
+ && _pCameraPresentationModel->GetRecorderState() != RECORDER_STATE_RECORDING
)
{
if (source.Equals(*__pThumbnailPanel) == true)
String controlName = L"";
result r = E_SUCCESS;
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("OnTouchMoved >> TerminateApp Execution");
return;
{
r = DrawExposureSlider(currentPosition, DRAW_MOVED);
TryReturnVoid(r == E_SUCCESS, "DrawExposureSlider() fail[%s]", GetErrorMessage(r));
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- TryReturnVoid(__pExposureCloseTimer != null, "__pExposureCloseTimer is null");
- __pExposureCloseTimer->Cancel();
+ TryReturnVoid(_pExposureCloseTimer != null, "_pExposureCloseTimer is null");
+ _pExposureCloseTimer->Cancel();
}
}
AppLogDebug("EXIT");
CameraApp* pCameraApp = static_cast<CameraApp*>(CameraApp::GetInstance());
result r = E_SUCCESS;
- AppLogDebug("__pAppTimer expire");
+ AppLogDebug("_pAppTimer expire");
+ EndRecordTimer();
DeleteTimer();
- __isRecording = false;
+ _isRecording = false;
- __pCamcorderPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
r = SendAppControlResult(pCameraApp->GetRequestId());
TryReturnVoid(r == E_SUCCESS, "SendAppControlResult [%s]", GetErrorMessage(r));
AppLogDebug("ENTER");
result r = E_SUCCESS;
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
__pCameraInfoPanel->SetDrawPopupTimerUpdate(false);
__pCameraInfoPanel->Invalidate(true);
- __isRecording = true;
+ _isRecording = true;
__setTimerInterval = false;
- __pCamcorderPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
- __pCamcorderPresentationModel->StartRecord();
+ _pCameraPresentationModel->StartRecord();
r = StartRecordTimer();
TryReturnVoid(r == E_SUCCESS, "StartRecordTimer() fail[%s]", GetErrorMessage(r));
CamcorderForm::OnHelpCloseTimerExpired(void)
{
AppLogDebug("ENTER");
- if (__pHelpCloseTimer)
+ if (_pHelpCloseTimer)
{
- __pHelpCloseTimer->Cancel();
+ _pHelpCloseTimer->Cancel();
- delete __pHelpCloseTimer;
- __pHelpCloseTimer = null;
+ delete _pHelpCloseTimer;
+ _pHelpCloseTimer = null;
}
__pHelpGoToGallery->SetShowState(false);
CamcorderForm::OnPopupTimerExpired(void)
{
AppLogDebug("ENTER");
- if (__isRecording != true)
+ if (_isRecording != true)
{
- __timeCount--;
+ _timeCount--;
__pCameraInfoPanel->SetDrawPopupTimerUpdate(true);
- __pCameraInfoPanel->SetDrawPopupTimerCount(__timeCount);
+ __pCameraInfoPanel->SetDrawPopupTimerCount(_timeCount);
__pCameraInfoPanel->Invalidate(true);
- AppLogDebug("__timeCount=%d", __timeCount);
+ AppLogDebug("_timeCount=%d", _timeCount);
- if (__timeCount == INDEX_UNIT_ZERO || __timeCount == INDEX_UNIT_ONE)
+ if (_timeCount == INDEX_UNIT_ZERO || _timeCount == INDEX_UNIT_ONE)
{
StopPopupTimer();
}
AppLogDebug("ENTER");
result r = E_SUCCESS;
- if (__isRecording == true)
+ if (_isRecording == true)
{
__recordTimeCount++;
AppLogDebug("__pRecordTimer expire");
- __recordingMaxTime = __pCamcorderPresentationModel->GetMaxRecordingTime();
+ __recordingMaxTime = _pCameraPresentationModel->GetMaxRecordingTime();
r = DrawRecord(true);
TryReturnVoid(r == E_SUCCESS, "DrawRecord() fail[%s]", GetErrorMessage(r));
CamcorderForm::OnExposureCloseTimerExpired(void)
{
AppLogDebug("ENTER");
- __closeTimerValue++;
+ _closeTimerValue++;
- AppLogDebug("__closeTimerValue expire %d", __closeTimerValue);
+ AppLogDebug("_closeTimerValue expire %d", _closeTimerValue);
- if (__closeTimerValue == EXPOSURE_TIMER_IS_ALIVE)
+ if (_closeTimerValue == EXPOSURE_TIMER_IS_ALIVE)
{
if (__pCameraInfoPanel->GetDrawExposure() == true)
{
Invalidate(true);
}
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
AppLogDebug("EXIT");
}
__pBatteryState->SetPosition(X_INDICATOR_BATTERY_LANDSCAPE, Y_INDICATOR_BATTERY_LANDSCAPE);
}
- __chargingCount++;
+ _chargingCount++;
- if (__chargingCount % DIVIDE_BY_TWO)
+ if (_chargingCount % DIVIDE_BY_TWO)
{
pBitmap = ResourceManager::GetBitmapN(RESOURCE_IC_CAMERA_BATTERY_20);
}
}
TryCatch(pBitmap != null, r = E_SYSTEM, "FlashButton::pBitmap is null");
- if (__chargingCount >= BATTERY_STATE_20)
+ if (_chargingCount >= BATTERY_STATE_20)
{
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
}
- __blinkCount++;
+ _blinkCount++;
__pBatteryState->SetBackgroundBitmap(*pBitmap);
__pBatteryState->Invalidate(true);
AppLogDebug("__batteryStatus = %d", __batteryStatus);
- AppLogDebug("__chargingCount = %d", __chargingCount);
- AppLogDebug("__blinkCount = %d", __blinkCount);
+ AppLogDebug("_chargingCount = %d", _chargingCount);
+ AppLogDebug("_blinkCount = %d", _blinkCount);
delete pBitmap;
pBitmap = null;
AppLogDebug("batteryLevel = %d", batteryLevel);
- __chargingCount++;
+ _chargingCount++;
AppLogDebug("__batteryStatus = %d", __batteryStatus);
- AppLogDebug("__chargingCount = %d", __chargingCount);
+ AppLogDebug("_chargingCount = %d", _chargingCount);
- if ((__batteryStatus == BATTERY_STATE_0 || __batteryStatus == BATTERY_STATE_1) && __chargingCount == INDEX_UNIT_ONE)
+ if ((__batteryStatus == BATTERY_STATE_0 || __batteryStatus == BATTERY_STATE_1) && _chargingCount == INDEX_UNIT_ONE)
{
pBitmap = ResourceManager::GetBitmapN(RESOURCE_IC_CAMERA_BATTERY_LOW);
}
else
{
- pBitmap = ResourceManager::GetBitmapN(__batteryStatus + __chargingCount);
+ pBitmap = ResourceManager::GetBitmapN(__batteryStatus + _chargingCount);
}
TryCatch(pBitmap != null, r = E_SYSTEM, "FlashButton::pBitmap is null");
- maxChargingCnt = (static_cast<int>(__batteryStatus)) + __chargingCount;
+ maxChargingCnt = (static_cast<int>(__batteryStatus)) + _chargingCount;
AppLogDebug("maxCount = %d", maxChargingCnt);
if (maxChargingCnt >= BATTERY_STATE_20)
{
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
}
__pBatteryState->SetBackgroundBitmap(*pBitmap);
__pCameraInfoPanel->Invalidate(true);
- r = __pMakerFocusTimer->Cancel();
+ r = _pMakerFocusTimer->Cancel();
- delete __pMakerFocusTimer;
- __pMakerFocusTimer = null;
+ delete _pMakerFocusTimer;
+ _pMakerFocusTimer = null;
AppLogDebug("EXIT");
}
CamcorderForm::OnTimerExpired(Tizen::Base::Runtime::Timer& timer)
{
AppLogDebug("ENTER");
- if (timer.Equals(*__pAppTimer))
+ if (timer.Equals(*_pAppTimer))
{
- AppLogDebug("__pAppTimer");
+ AppLogDebug("_pAppTimer");
OnAppTimerExpired();
}
- else if (timer.Equals(*__pIntervalValueTimer))
+ else if (timer.Equals(*_pIntervalValueTimer))
{
- AppLogDebug("__pIntervalValueTimer");
+ AppLogDebug("_pIntervalValueTimer");
OnSettingTimerExpired();
StartInitChargingTimer();
}
- else if (timer.Equals(*__pPopupTimer))
+ else if (timer.Equals(*_pPopupTimer))
{
- AppLogDebug("__pPopupTimer");
+ AppLogDebug("_pPopupTimer");
OnPopupTimerExpired();
}
else if (timer.Equals(*__pRecordTimer))
__pRecordButton->SetShowState(true);
__pRecordButton->Invalidate(true);
}
- else if (timer.Equals(*__pExposureCloseTimer))
+ else if (timer.Equals(*_pExposureCloseTimer))
{
- AppLogDebug("__pExposureCloseTimer");
+ AppLogDebug("_pExposureCloseTimer");
OnExposureCloseTimerExpired();
}
- else if (timer.Equals(*__pMakerFocusTimer))
+ else if (timer.Equals(*_pMakerFocusTimer))
{
- AppLogDebug("__pMakerFocusTimer");
+ AppLogDebug("_pMakerFocusTimer");
OnMakerFocusTimerExpired();
}
- else if (timer.Equals(*__pHelpCloseTimer))
+ else if (timer.Equals(*_pHelpCloseTimer))
{
AppLogDebug("__pHelpCloseTimer");
OnHelpCloseTimerExpired();
}
- else if (timer.Equals(*__pChargingTimer))
+ else if (timer.Equals(*_pChargingTimer))
{
result r = E_SUCCESS;
- AppLogDebug("__pChargingTimer");
+ AppLogDebug("_pChargingTimer");
bool isCharging = false;
__batteryStatus = GetCurrentBatteryState();
AppLogDebug("__batteryStatus = %d", __batteryStatus);
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ isCharging = _pCameraPresentationModel->IsCharging();
if (isCharging)
{
if (__batteryStatus == BATTERY_STATE_20)
{
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
- __blinkCount = INDEX_UNIT_ZERO;
+ _blinkCount = INDEX_UNIT_ZERO;
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
StartInitChargingCompletedTimer();
}
}
else
{
- __chargingCount = 0;
+ _chargingCount = 0;
- __blinkCount = INDEX_UNIT_ZERO;
+ _blinkCount = INDEX_UNIT_ZERO;
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
if (__batteryStatus == BATTERY_STATE_20)
{
- AppLogDebug("__pChargingTimer -> __pChargingCompletedTimer");
+ AppLogDebug("_pChargingTimer -> __pChargingCompletedTimer");
StartInitChargingCompletedTimer();
}
}
}
- else if (timer.Equals(*__pChargingCompletedTimer))
+ else if (timer.Equals(*_pChargingCompletedTimer))
{
result r = E_SUCCESS;
AppLogDebug("__pChargingCompletedTimer");
bool isCharging = false;
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ isCharging = _pCameraPresentationModel->IsCharging();
__batteryStatus = GetCurrentBatteryState();
AppLogDebug("__batteryStatus = %d", __batteryStatus);
if (isCharging == false && __batteryStatus == BATTERY_STATE_20)
{
- if (__blinkCount == INDEX_UNIT_TWENTY)
+ if (_blinkCount == INDEX_UNIT_TWENTY)
{
AppLogDebug("__pChargingCompletedTimer cancel");
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
- __blinkCount = INDEX_UNIT_ZERO;
+ _blinkCount = INDEX_UNIT_ZERO;
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
CheckBatteryStatus();
}
{
AppLogDebug("isCharging = true >> __pChargingCompletedTimer cancel");
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
- __blinkCount = INDEX_UNIT_ZERO;
+ _blinkCount = INDEX_UNIT_ZERO;
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
CheckBatteryStatus();
}
}
- else if (timer.Equals(*__pPreviewFailPopupTimer))
+ else if (timer.Equals(*_pPreviewFailPopupTimer))
{
AppLogDebug("__pPreviewFailPopupTimer");
- __pPreviewFailPopupTimer->Cancel();
+ _pPreviewFailPopupTimer->Cancel();
- if (__pCamcorderPresentationModel->GetStartPreviewException())
+ if (_pCameraPresentationModel->GetStartPreviewException())
{
OnPreviewFailPopupTimerExpired();
}
{
if (clientArea.height == DISPLAY_WVGA)
{
- __pCamcorderPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_WVGA);
+ _pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_WVGA);
}
else
{
- __pCamcorderPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_HD);
+ _pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_HD);
}
}
else
{
if (clientArea.width == DISPLAY_WVGA)
{
- __pCamcorderPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_WVGA);
+ _pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_WVGA);
}
else
{
- __pCamcorderPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_HD);
+ _pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_HD);
}
}
__pActionPanel->AddTouchEventListener(*this);
__pRecordButton->SetName(IDS_RECORDE_BUTTON_NAME);
__pRecordButton->AddTouchEventListener(*this);
- AppLogDebug("GetDisplayResolutionType = %d", __pCamcorderPresentationModel->GetDisplayResolutionType());
+ AppLogDebug("GetDisplayResolutionType = %d", _pCameraPresentationModel->GetDisplayResolutionType());
if (__dir == ORIENTATION_STATUS_PORTRAIT_REVERSE
|| __dir == ORIENTATION_STATUS_PORTRAIT)
ptModeChangeButton = Point(X_ACTION_PANEL_CAMERA_CAMCODER_BUTTON_LANDSCAPE, Y_ACTION_PANEL_CAMERA_CAMCODER_BUTTON_LANDSCAPE);
}
- AppLogDebug("GetDisplayResolutionType = %d", __pCamcorderPresentationModel->GetDisplayResolutionType());
+ AppLogDebug("GetDisplayResolutionType = %d", _pCameraPresentationModel->GetDisplayResolutionType());
if (__dir == ORIENTATION_STATUS_PORTRAIT
|| __dir == ORIENTATION_STATUS_PORTRAIT_REVERSE)
Construct(L"IDL_CAMCORDER_FORM");
- __pCamcorderPresentationModel = CameraPresentationModel::GetInstance();
- TryCatch(__pCamcorderPresentationModel != null, r = E_SYSTEM, "__pCamcorderPresentationModel is null");
+ _pCameraPresentationModel = CameraPresentationModel::GetInstance();
+ TryCatch(_pCameraPresentationModel != null, r = E_SYSTEM, "_pCameraPresentationModel is null");
AppLogDebug("EXIT");
return E_SUCCESS;
CamcorderForm::InitAppTimer(void)
{
AppLogDebug("ENTER");
- __pAppTimer = new (std::nothrow) Timer();
- __pAppTimer->Construct(*this);
+ _pAppTimer = new (std::nothrow) Timer();
+ _pAppTimer->Construct(*this);
AppLogDebug("EXIT");
}
CamcorderForm::InitChargingTimer(void)
{
AppLogDebug("ENTER");
- __pChargingTimer = new (std::nothrow) Timer();
- __pChargingTimer->Construct(*this);
+ _pChargingTimer = new (std::nothrow) Timer();
+ _pChargingTimer->Construct(*this);
AppLogDebug("EXIT");
}
CamcorderForm::InitChargingCompletedTimer(void)
{
AppLogDebug("ENTER");
- __pChargingCompletedTimer = new (std::nothrow) Timer();
- __pChargingCompletedTimer->Construct(*this);
+ _pChargingCompletedTimer = new (std::nothrow) Timer();
+ _pChargingCompletedTimer->Construct(*this);
AppLogDebug("EXIT");
}
CamcorderForm::InitPreviewFailPopupTimer(void)
{
AppLogDebug("ENTER");
- __pPreviewFailPopupTimer = new (std::nothrow) Timer();
- __pPreviewFailPopupTimer->Construct(*this);
+ _pPreviewFailPopupTimer = new (std::nothrow) Timer();
+ _pPreviewFailPopupTimer->Construct(*this);
AppLogDebug("EXIT");
}
CamcorderForm::InitMakerFocusTimer(void)
{
AppLogDebug("ENTER");
- __pMakerFocusTimer = new (std::nothrow) Timer();
- __pMakerFocusTimer->Construct(*this);
+ _pMakerFocusTimer = new (std::nothrow) Timer();
+ _pMakerFocusTimer->Construct(*this);
AppLogDebug("EXIT");
}
CamcorderForm::InitSettingTimer(void)
{
AppLogDebug("ENTER");
- __pIntervalValueTimer = new (std::nothrow) Timer();
- __pIntervalValueTimer->Construct(*this);
+ _pIntervalValueTimer = new (std::nothrow) Timer();
+ _pIntervalValueTimer->Construct(*this);
AppLogDebug("EXIT");
}
result r = E_SUCCESS;
bool isCharging = false;
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ isCharging = _pCameraPresentationModel->IsCharging();
- __chargingCount = 0;
+ _chargingCount = 0;
if (isCharging)
{
- if (__pChargingTimer)
+ if (_pChargingTimer)
{
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
- r = __pChargingTimer->StartAsRepeatable(CAMCORDER_CHARGING_TIMER);
- TryReturnVoid(r == E_SUCCESS, "__pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
+ r = _pChargingTimer->StartAsRepeatable(CAMCORDER_CHARGING_TIMER);
+ TryReturnVoid(r == E_SUCCESS, "_pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
}
}
else
{
- if (__pChargingTimer)
+ if (_pChargingTimer)
{
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
}
}
AppLogDebug("EXIT");
AppLogDebug("ENTER");
result r = E_SUCCESS;
- TryReturnVoid(__pCamcorderPresentationModel != null, "__pCamcorderPresentationModel is null");
- if (__pCamcorderPresentationModel->GetRecorderState() != RECORDER_STATE_RECORDING)
+ TryReturnVoid(_pCameraPresentationModel != null, "_pCameraPresentationModel is null");
+ if (_pCameraPresentationModel->GetRecorderState() != RECORDER_STATE_RECORDING)
{
- AppLogDebug("StartInitAppTimer : RecorderState() = %d", __pCamcorderPresentationModel->GetRecorderState());
+ AppLogDebug("StartInitAppTimer : RecorderState() = %d", _pCameraPresentationModel->GetRecorderState());
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
TryReturnVoid(r == E_SUCCESS, "Timer::Start() fail[%s]", GetErrorMessage(r));
}
AppLogDebug("EXIT");
AppLogDebug("ENTER");
result r = E_SUCCESS;
- TryReturnVoid(__pPreviewFailPopupTimer != null, "__pPreviewFailPopupTimer is null");
+ TryReturnVoid(_pPreviewFailPopupTimer != null, "__pPreviewFailPopupTimer is null");
- __pPreviewFailPopupTimer->Cancel();
+ _pPreviewFailPopupTimer->Cancel();
- r = __pPreviewFailPopupTimer->Start(PREVIEW_FAIL_TIMER);
+ r = _pPreviewFailPopupTimer->Start(PREVIEW_FAIL_TIMER);
TryReturnVoid(r == E_SUCCESS, "__pPreviewFailPopupTimer::Start() fail[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
}
result r = E_SUCCESS;
bool isCharging = false;
- TryReturnVoid(__pChargingCompletedTimer != null, "__pChargingCompletedTimer is null");
+ TryReturnVoid(_pChargingCompletedTimer != null, "__pChargingCompletedTimer is null");
- isCharging = __pCamcorderPresentationModel->IsCharging();
+ isCharging = _pCameraPresentationModel->IsCharging();
__batteryStatus = GetCurrentBatteryState();
AppLogDebug("__batteryStatus = %d" , __batteryStatus);
if (isCharging && __batteryStatus == BATTERY_STATE_20)
{
- if (__pChargingCompletedTimer)
+ if (_pChargingCompletedTimer)
{
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
}
- __chargingCount = 0;
+ _chargingCount = 0;
- __blinkCount = 0;
+ _blinkCount = 0;
r = DrawBatteryLevelFull();
- TryReturnVoid(r == E_SUCCESS, "__pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
+ TryReturnVoid(r == E_SUCCESS, "_pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
return;
}
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
if (__batteryStatus == BATTERY_STATE_20)
{
- if (__pChargingCompletedTimer)
+ if (_pChargingCompletedTimer)
{
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
- r = __pChargingCompletedTimer->StartAsRepeatable(CAMCORDER_TIMER_ONE_SEC);
- TryReturnVoid(r == E_SUCCESS, "__pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
+ r = _pChargingCompletedTimer->StartAsRepeatable(CAMCORDER_TIMER_ONE_SEC);
+ TryReturnVoid(r == E_SUCCESS, "_pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
}
}
else
{
- if (__pChargingCompletedTimer)
+ if (_pChargingCompletedTimer)
{
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
}
- __chargingCount = 0;
- __blinkCount = 0;
+ _chargingCount = 0;
+ _blinkCount = 0;
CheckBatteryStatus();
}
CamcorderForm::StopInitAppTimer(void)
{
AppLogDebug("ENTER");
- if (__pAppTimer)
+ if (_pAppTimer)
{
- __pAppTimer->Cancel();
+ _pAppTimer->Cancel();
}
AppLogDebug("EXIT");
}
CamcorderForm::StopInitChargingTimer(void)
{
AppLogDebug("ENTER");
- __chargingCount = 0;
+ _chargingCount = 0;
- if (__pChargingTimer)
+ if (_pChargingTimer)
{
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
}
AppLogDebug("EXIT");
}
case SET_RECORD_START_TIMER_2_SEC:
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
- r = __pIntervalValueTimer->Start(CAMCORDER_TIMER_2_SEC);
- TryCatch(r == E_SUCCESS, , "__pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
+ r = _pIntervalValueTimer->Start(CAMCORDER_TIMER_2_SEC);
+ TryCatch(r == E_SUCCESS, , "_pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
}
break;
case SET_RECORD_START_TIMER_5_SEC:
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
- r = __pIntervalValueTimer->Start(CAMCORDER_TIMER_5_SEC);
- TryCatch(r == E_SUCCESS, , "__pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
+ r = _pIntervalValueTimer->Start(CAMCORDER_TIMER_5_SEC);
+ TryCatch(r == E_SUCCESS, , "_pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
}
break;
case SET_RECORD_START_TIMER_10_SEC:
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
- r = __pIntervalValueTimer->Start(CAMCORDER_TIMER_10_SEC);
- TryCatch(r == E_SUCCESS, , "__pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
+ r = _pIntervalValueTimer->Start(CAMCORDER_TIMER_10_SEC);
+ TryCatch(r == E_SUCCESS, , "_pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
}
break;
CamcorderForm::CancelTimer(void)
{
AppLogDebug("ENTER");
- if (__pAppTimer != null)
+ if (_pAppTimer != null)
{
- __pAppTimer->Cancel();
+ _pAppTimer->Cancel();
}
- if (__pIntervalValueTimer != null)
+ if (_pIntervalValueTimer != null)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __pPopupTimer->Cancel();
+ _pPopupTimer->Cancel();
}
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
- if (__pHelpCloseTimer)
+ if (_pHelpCloseTimer)
{
- __pHelpCloseTimer->Cancel();
+ _pHelpCloseTimer->Cancel();
}
- if (__pChargingCompletedTimer != null)
+ if (_pChargingCompletedTimer != null)
{
- __chargingCount = 0;
- __blinkCount = 0;
- __pChargingCompletedTimer->Cancel();
+ _chargingCount = 0;
+ _blinkCount = 0;
+ _pChargingCompletedTimer->Cancel();
}
- if (__pPreviewFailPopupTimer != null)
+ if (_pPreviewFailPopupTimer != null)
{
- __pPreviewFailPopupTimer->Cancel();
- }
- AppLogDebug("EXIT");
-}
-
-void
-CamcorderForm::DeleteTimer(void)
-{
- AppLogDebug("ENTER");
- EndRecordTimer();
-
- if (__pAppTimer)
- {
- __pAppTimer->Cancel();
-
- delete __pAppTimer;
- __pAppTimer = null;
- }
-
- if (__pIntervalValueTimer)
- {
- __pIntervalValueTimer->Cancel();
-
- delete __pIntervalValueTimer;
- __pIntervalValueTimer = null;
- }
-
- if (__pPopupTimer)
- {
- __pPopupTimer->Cancel();
-
- delete __pPopupTimer;
- __pPopupTimer = null;
- }
-
- if (__pExposureCloseTimer)
- {
- __pExposureCloseTimer->Cancel();
-
- delete __pExposureCloseTimer;
- __pExposureCloseTimer = null;
- }
-
- if (__pMakerFocusTimer)
- {
- __pMakerFocusTimer->Cancel();
-
- delete __pMakerFocusTimer;
- __pMakerFocusTimer = null;
- }
-
- if (__pHelpCloseTimer)
- {
- __pHelpCloseTimer->Cancel();
-
- delete __pHelpCloseTimer;
- __pHelpCloseTimer = null;
- }
-
- if (__pChargingTimer)
- {
- __pChargingTimer->Cancel();
-
- delete __pChargingTimer;
- __pChargingTimer = null;
- }
-
- if (__pChargingCompletedTimer != null)
- {
- __chargingCount = 0;
- __blinkCount = 0;
- __pChargingCompletedTimer->Cancel();
-
- delete __pChargingTimer;
- __pChargingTimer = null;
- }
-
- if (__pPreviewFailPopupTimer != null)
- {
- __pPreviewFailPopupTimer->Cancel();
-
- delete __pPreviewFailPopupTimer;
- __pPreviewFailPopupTimer = null;
+ _pPreviewFailPopupTimer->Cancel();
}
AppLogDebug("EXIT");
}
r = __pRecordingResolutionList->Construct();
TryCatch(r == E_SUCCESS, , "__pRecordingResolutionList construct fail[%s]", GetErrorMessage(r));
- pTempList = __pCamcorderPresentationModel->GetRecordingResolutionList();
+ pTempList = _pCameraPresentationModel->GetRecordingResolutionList();
TryCatch(pTempList != null, , "GetRecordingResolutionList() return null");
tot = pTempList->GetCount();
return 0;
}
-void
-CamcorderForm::OnKeyPressed(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode)
-{
- AppLogDebug("ENTER OnKeyPressed Control : %ls, KeyCode : %d", source.GetName().GetPointer(), keyCode);
- AppLogDebug("EXIT");
-}
-
-void
-CamcorderForm::OnKeyReleased(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode)
-{
- AppLogDebug("ENTER OnKeyReleased Control : %ls, KeyCode : %d", source.GetName().GetPointer(), keyCode);
- AppLogDebug("EXIT");
-}
-
-void
-CamcorderForm::OnKeyLongPressed(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode)
-{
- AppLogDebug("ENTER OnKeyLongPressed Control : %ls, KeyCode : %d", source.GetName().GetPointer(), keyCode);
- AppLogDebug("EXIT");
-}
-
int
CamcorderForm::GetTimerIntervalValue(void) const
{
result r = E_SUCCESS;
int timerInterval = 0;
- r = __pCamcorderPresentationModel->GetValue(TIMER_INTERVAL, timerInterval);
+ r = _pCameraPresentationModel->GetValue(TIMER_INTERVAL, timerInterval);
TryCatch(r == E_SUCCESS, , "Faled to get value to registry");
AppLogDebug("EXIT");
AppLogDebug("ENTER");
result r = E_SUCCESS;
- r = __pCamcorderPresentationModel->SetValue(GUIDELINE_ENABLE, guideLineEnable);
+ r = _pCameraPresentationModel->SetValue(GUIDELINE_ENABLE, guideLineEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
}
-void
-CamcorderForm::SetStorageType(int storageType)
-{
- AppLogDebug("ENTER");
- result r = E_SUCCESS;
- if (storageType == STORAGE_TYPE_PHONE)
- {
- r = __pCamcorderPresentationModel->SetValue(STORAGE_TYPE, storageType);
- TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
-
- __pCamcorderPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
- }
- else if (storageType == STORAGE_TYPE_MEMORYCARD)
- {
- if (__pCamcorderPresentationModel->IsStorageCardMounted() == true)
- {
- AppLogDebug("StorageCard mount");
-
- r = __pCamcorderPresentationModel->SetValue(STORAGE_TYPE, storageType);
- TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
-
- __pCamcorderPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_MOUNT);
- }
- else
- {
- AppLogDebug("StorageCard unmount");
- __pCamcorderPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
- }
- }
- AppLogDebug("EXIT");
-}
-
result
CamcorderForm::RestoreDefaultSetting(void)
{
bool brighnesstValue = false;
int adjustValue = 0;
- r = __pCamcorderPresentationModel->ResetCameraSettingsRegistry( );
+ r = _pCameraPresentationModel->ResetCameraSettingsRegistry( );
TryCatch(r == E_SUCCESS, , "ResetCameraSettingsRegistry() fail[%s]", GetErrorMessage(r));
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(EXPOSURE_VALUE, adjustValue);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, adjustValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("adjustValue = %d", adjustValue);
- __pCamcorderPresentationModel->SetExposure(adjustValue);
+ _pCameraPresentationModel->SetExposure(adjustValue);
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(BRIGHTNESS_VALUE, adjustValue);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, adjustValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("adjustValue = %d", adjustValue);
- __pCamcorderPresentationModel->SetBrightness(adjustValue);
+ _pCameraPresentationModel->SetBrightness(adjustValue);
}
}
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
if (r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, adjustValue);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, adjustValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
if (r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, adjustValue);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, adjustValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
}
{
AppLogDebug("adjustValue = %d", adjustValue);
- __pCamcorderPresentationModel->SetWhiteBalance((CameraWhiteBalance)adjustValue);
+ _pCameraPresentationModel->SetWhiteBalance((CameraWhiteBalance)adjustValue);
}
AppLogDebug("EXIT");
int selfPortraitEnable = 0;
bool focusSupport = false;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (__dir == ORIENTATION_STATUS_PORTRAIT
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
if (focusSupport == true && r == E_SUCCESS)
BufferInfo bufferinfo;
bool isInitCameraStaus = false;
- if (__pAppTimer != null)
+ if (_pAppTimer != null)
{
- __pAppTimer->Cancel();
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
}
if (direction == CAMCORDER_FORM_SECONDARY_MODE)
{
- r = __pCamcorderPresentationModel->ToggleCameraDirection(CameraPresentationModel::CAMERA_MODE_RECORD, CameraPresentationModel::CAMERA_DIRECTION_FRONT);
+ r = _pCameraPresentationModel->ToggleCameraDirection(CameraPresentationModel::CAMERA_MODE_RECORD, CameraPresentationModel::CAMERA_DIRECTION_FRONT);
}
else if (direction == CAMCORDER_FORM_PRIMARY_MODE)
{
- r = __pCamcorderPresentationModel->ToggleCameraDirection(CameraPresentationModel::CAMERA_MODE_RECORD, CameraPresentationModel::CAMERA_DIRECTION_BACK);
+ r = _pCameraPresentationModel->ToggleCameraDirection(CameraPresentationModel::CAMERA_MODE_RECORD, CameraPresentationModel::CAMERA_DIRECTION_BACK);
}
- TryCatch(r == E_SUCCESS, , "__pCamcorderPresentationModel->ToggleCameraDirection() fail[%s]", GetErrorMessage(r));
+ TryCatch(r == E_SUCCESS, , "_pCameraPresentationModel->ToggleCameraDirection() fail[%s]", GetErrorMessage(r));
- dim = __pCamcorderPresentationModel->GetPreviewResolution();
+ dim = _pCameraPresentationModel->GetPreviewResolution();
AppLogDebug("CamcorderForm::GetPreviewResolution(W:%d, H:%d)", dim.width, dim.height);
AppLogDebug("SelfPortraitMode __screenMode [%d]", __screenMode);
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryCatch(r == E_SUCCESS, , "GetBackgroundBufferInfo fail[%s]", GetErrorMessage(r));
- isInitCameraStaus = __pCamcorderPresentationModel->GetInitCameraStatus();
+ isInitCameraStaus = _pCameraPresentationModel->GetInitCameraStatus();
AppLogDebug("isInitCameraStaus [%d]", isInitCameraStaus);
if (isInitCameraStaus)
{
- __pCamcorderPresentationModel->StartPreview(&bufferinfo);
+ AppLogDebug("Ravi: calling camcordersettings");
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCamcorderPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
InDrawFocus();
SetCamcorderSettingsDevice();
}
+ else
+ {
+ AppLogDebug("Ravi: not calling camcordersettings");
+ }
AppLogDebug("EXIT");
return r;
{
result r = E_SUCCESS;
- r = __pCamcorderPresentationModel->SetValue(OVERLAY_HELP_ENABLE, SCREEN_OVERLAY_HELP_ENABLE);
+ r = _pCameraPresentationModel->SetValue(OVERLAY_HELP_ENABLE, SCREEN_OVERLAY_HELP_ENABLE);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("Setting - OVERLAY_HELP_ENABLE = %d", OVERLAY_HELP_ENABLE);
ResourceId resIdNormal = RESOURCE_ID_CAMERA_MODE_FLASH_AUTO_NOR;
ResourceId resIdPress = RESOURCE_ID_CAMERA_MODE_FLASH_AUTO_PRESS;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue Reg Fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
}
}
- r = __pCamcorderPresentationModel->SetValue(FLASH_MODE_PRIMARY, regVal);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, regVal);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
TryCatch(__pSettingPanel != null, r = E_SYSTEM, "__pSettingPanel is null");
SetCamcorderTabSettingMainMenuCount(MENU_COUNT_CLEAR);
SetCamcorderTabSubMenuListviewState(MENU_COUNT_CLEAR, CAMCORDER_SUB_MENU_CONTENT_MAX);
- __pCamcorderPresentationModel->SetFlashMode(cameraFlashMode);
+ _pCameraPresentationModel->SetFlashMode(cameraFlashMode);
AppLogDebug("EXIT");
return r;
int regVal = 0;
int selfPortraitEnable = 0;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
AppLogDebug("result is %s",GetErrorMessage(r));
}
if (r == E_SUCCESS)
{
- __pCamcorderPresentationModel->SetWhiteBalance((CameraWhiteBalance)index);
+ _pCameraPresentationModel->SetWhiteBalance((CameraWhiteBalance)index);
}
else
{
AppLogDebug("regVal = %d", regVal);
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->SetValue(WHITE_BALANCE_TYPE_PRIMARY, regVal);
+ r = _pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_PRIMARY, regVal);
TryCatch(r == E_SUCCESS, , "Faled to set value to registry");
}
else
{
- r = __pCamcorderPresentationModel->SetValue(WHITE_BALANCE_TYPE_SECONDARY, regVal);
+ r = _pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_SECONDARY, regVal);
TryCatch(r == E_SUCCESS, , "Faled to set value to registry");
}
AppLogDebug("Set vaule");
- r = __pCamcorderPresentationModel->SetValue(GUIDELINE_ENABLE, regVal);
+ r = _pCameraPresentationModel->SetValue(GUIDELINE_ENABLE, regVal);
TryCatch(r == E_SUCCESS, , "Faled to set value to registry");
AppLogDebug("EXIT");
AppLogDebug("Setting - Storage type = card");
storage = STORAGE_TYPE_MEMORYCARD;
- if (__pCamcorderPresentationModel->IsStorageCardMounted() == true)
+ if (_pCameraPresentationModel->IsStorageCardMounted() == true)
{
SetStorageType(storage);
}
break;
}
- __pCamcorderPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_RECORD);
+ _pCameraPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_RECORD);
Update(false);
AppLogDebug("FileEventManager()::Construct() fail[%s]", GetErrorMessage(r));
}
- filePath = __pCamcorderPresentationModel->GetfilePath(storage);
+ filePath = _pCameraPresentationModel->GetfilePath(storage);
AppLogDebug("filePath %ls", filePath.GetPointer());
if (File::IsFileExist(__pFileEventPath))
__settingTimeInterval = index;
regVal = index;
- r = __pCamcorderPresentationModel->SetValue(TIMER_INTERVAL, regVal);
+ r = _pCameraPresentationModel->SetValue(TIMER_INTERVAL, regVal);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
CamcorderForm::SubListPopupResolutionMode(int index)
{
AppLogDebug("ENTER");
- IList* pList = __pCamcorderPresentationModel->GetRecordingResolutionList();
+ IList* pList = _pCameraPresentationModel->GetRecordingResolutionList();
int resolutionCnt = 0;
result r = E_SUCCESS;
int selfPortraitEnable = 0;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (pList)
{
resolutionCnt = pList->GetCount() - INDEX_UNIT_ONE;
//Dimension dimResolution = *(static_cast<Dimension*>(pList->GetAt(resolutionCnt - index)));
- Dimension dimResolution = __pCamcorderPresentationModel->GetRecordingResolution();
+ Dimension dimResolution = _pCameraPresentationModel->GetRecordingResolution();
AppLogDebug("CamcorderForm::GetPreviewResolution(W:%d, H:%d)", dimResolution.width, dimResolution.height);
if ((__pRecordingResolutionWidth == dimResolution.width )&& (__pRecordingResolutionHeight == dimResolution.height))
}
else
{
- __pCamcorderPresentationModel->StopPreview();
+ _pCameraPresentationModel->StopPreview();
- __pCamcorderPresentationModel->SetRecordingResolution(dimResolution);
+ _pCameraPresentationModel->SetRecordingResolution(dimResolution);
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
{
regVal = value;
- r = __pCamcorderPresentationModel->SetValue(OVERLAY_HELP_ENABLE, regVal);
+ r = _pCameraPresentationModel->SetValue(OVERLAY_HELP_ENABLE, regVal);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("Setting - OVERLAY_HELP_ENABLE = %d", OVERLAY_HELP_ENABLE);
int selfPortraitEnable = 0;
CamcorderGeneralTabSubMenuContent idx = CAMCORDER_GENERAL_TAB_SUB_MENU_CONTENT_MAX;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "Reg GetValue() fail[%s]", GetErrorMessage(r));
idx = GetGeneralTabSettingSubMenuMode();
result r = E_SUCCESS;
int settingTimer = 0;
- __timeCount = 0;
+ _timeCount = 0;
- __pPopupTimer = new (std::nothrow) Timer();
- __pPopupTimer->Construct(*this);
+ _pPopupTimer = new (std::nothrow) Timer();
+ _pPopupTimer->Construct(*this);
- r = __pPopupTimer->StartAsRepeatable(CAMCORDER_TIMER_1_SEC);
- TryCatch(r == E_SUCCESS, , "__pPopupTimer start fail[%s]", GetErrorMessage(r));
+ r = _pPopupTimer->StartAsRepeatable(CAMCORDER_TIMER_1_SEC);
+ TryCatch(r == E_SUCCESS, , "_pPopupTimer start fail[%s]", GetErrorMessage(r));
- r = __pCamcorderPresentationModel->GetValue(TIMER_INTERVAL, settingTimer);
+ r = _pCameraPresentationModel->GetValue(TIMER_INTERVAL, settingTimer);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (settingTimer == SETTING_TIMER_RECORD_2_SEC)
{
- __timeCount = SETTING_TIMER_2_SEC_COUNT;
+ _timeCount = SETTING_TIMER_2_SEC_COUNT;
}
else if (settingTimer == SETTING_TIMER_RECORD_5_SEC)
{
- __timeCount = SETTING_TIMER_5_SEC_COUNT;
+ _timeCount = SETTING_TIMER_5_SEC_COUNT;
}
else if (settingTimer == SETTING_TIMER_RECORD_10_SEC)
{
- __timeCount = SETTING_TIMER_10_SEC_COUNT;
+ _timeCount = SETTING_TIMER_10_SEC_COUNT;
}
__pCameraInfoPanel->SetDrawPopupTimerUpdate(true);
- __pCameraInfoPanel->SetDrawPopupTimerCount(__timeCount);
+ __pCameraInfoPanel->SetDrawPopupTimerCount(_timeCount);
__pCameraInfoPanel->Invalidate(true);
return E_SUCCESS;
CATCH:
- delete __pPopupTimer;
- __pPopupTimer = null;
+ delete _pPopupTimer;
+ _pPopupTimer = null;
return r;
}
{
AppLogDebug("ENTER");
result r = E_SUCCESS;
- TryCatch(__pPopupTimer != null, r = E_SYSTEM, "__pPopupTimer is null");
+ TryCatch(_pPopupTimer != null, r = E_SYSTEM, "_pPopupTimer is null");
- r = __pPopupTimer->Cancel();
+ r = _pPopupTimer->Cancel();
- delete __pPopupTimer;
- __pPopupTimer = null;
+ delete _pPopupTimer;
+ _pPopupTimer = null;
AppLogDebug("EXIT");
return E_SUCCESS;
int selfPortraitEnable = 0;
int adjustValue = 0;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
AppLogDebug("CAMERA_SUB_MENU_CONTENT_EXPOSURE_MODE");
- r = __pCamcorderPresentationModel->GetValue(EXPOSURE_VALUE, adjustValue);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, adjustValue);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
AppLogDebug("adjustValue = %d", adjustValue);
- __pCamcorderPresentationModel->SetExposure(adjustValue);
+ _pCameraPresentationModel->SetExposure(adjustValue);
MakeSettingPopupTab(false);
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
AppLogDebug("CAMERA_SUB_MENU_CONTENT_EXPOSURE_MODE");
- r = __pCamcorderPresentationModel->GetValue(BRIGHTNESS_VALUE, adjustValue);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, adjustValue);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
AppLogDebug("adjustValue = %d", adjustValue);
- __pCamcorderPresentationModel->SetBrightness(adjustValue);
+ _pCameraPresentationModel->SetBrightness(adjustValue);
MakeSettingPopupTab(false);
Rectangle rect = Rectangle(X_PREVIEW_OVERLAY_LANDSCAPE, Y_PREVIEW_OVERLAY_LANDSCAPE, W_PREVIEW_OVERLAY_LANDSCAPE, H_PREVIEW_OVERLAY_LANDSCAPE);
- if (__isRecording || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ if (_isRecording || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
{
if (__dir == ORIENTATION_STATUS_PORTRAIT
|| __dir == ORIENTATION_STATUS_PORTRAIT_REVERSE)
currentPosition.y = (H_PREVIEW_OVERLAY_LANDSCAPE / DIVIDE_BY_TWO);
}
- //if (__pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING || __isRecording == true)
+ //if (_pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING || _isRecording == true)
{
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Reg getValue fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
}
if (focusSupport == true && r == E_SUCCESS)
__pCameraInfoPanel->Invalidate(true);
}
- __pCamcorderPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
}
}
AppLogDebug("EXIT");
bool focusSupport = false;
Bitmap* pBitmap = null;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Reg getValue fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
}
pBitmap = ResourceManager::GetBitmapN(RESOURCE_ID_CAMCODER_AUTOFOCUS);
return E_SUCCESS;
}
- if (__pCamcorderPresentationModel->GetPreviewState() == false)
+ if (_pCameraPresentationModel->GetPreviewState() == false)
{
AppLogDebug("StartPreview do not call");
__pBackButton->SetEnabled(false);
return E_SUCCESS;
}
- AppLogDebug("RecorderState = %d", __pCamcorderPresentationModel->GetRecorderState());
- if (__pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING || __isRecording == true)
+ AppLogDebug("RecorderState = %d", _pCameraPresentationModel->GetRecorderState());
+ if (_pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING || _isRecording == true)
{
- if (__pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_STARTING)
+ if (_pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_STARTING)
{
AppLogDebug("No RECORDER_STATE_RECORDING AND PAUSE");
return E_SUCCESS;
}
else
{
- if (__isRecording == true)
+ if (_isRecording == true)
{
- AppLogDebug("No RECORDER_STATE_RECORDING and __isRecording = true >> DO NOT APP TERMINATE");
+ AppLogDebug("No RECORDER_STATE_RECORDING and _isRecording = true >> DO NOT APP TERMINATE");
return E_SUCCESS;
}
if (__pCameraInfoPanel->GetDrawExposure() == true)
{
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
__pCameraInfoPanel->SetDrawExposure(false);
}
else
{
- onVideoRecorderStopped = __pCamcorderPresentationModel->GetOnVideoRecorderStopped();
+ onVideoRecorderStopped = _pCameraPresentationModel->GetOnVideoRecorderStopped();
AppLogDebug("onVideoRecorderStopped = %d", onVideoRecorderStopped);
if (onVideoRecorderStopped == false)
bool onVideoRecorderStopped = false;
result r = E_SUCCESS;
- onVideoRecorderStopped = __pCamcorderPresentationModel->GetOnVideoRecorderStopped();
+ onVideoRecorderStopped = _pCameraPresentationModel->GetOnVideoRecorderStopped();
if (GetAppLaunchType() == APP_LAUNCH_TYPE_REQUESET)
{
AppLogDebug("PressBackButton >> Back to the App");
if (onVideoRecorderStopped == false)
{
- if (__isRecording == false)
+ if (_isRecording == false)
{
- __pCamcorderPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_CANCELED);
+ _pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_CANCELED);
}
r = TerminateApp();
result r = E_SUCCESS;
bool value = false;
- if (__pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ if (_pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
{
AppLogDebug("Return Camera transform");
}
else
{
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Reg getvalue fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CAMCORDER_FORM_PRIMARY_MODE)
{
AppLogDebug("PRIMARY -> SECONDARY");
- r = __pCamcorderPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
- TryReturnVoid(r == E_SUCCESS, "Reg setValue fail[%s]", GetErrorMessage(r));
-
- r = __pCamcorderPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY);
+ r = _pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY);
TryReturnVoid(r == E_SUCCESS, "Reg setValue fail[%s]", GetErrorMessage(r));
r = ToggleCameraDirection(CAMCORDER_FORM_SECONDARY_MODE);
TryReturnVoid(r == E_SUCCESS, "ToggleCameraDirection() fail[%s]", GetErrorMessage(r));
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
+ TryReturnVoid(r == E_SUCCESS, "Reg setValue fail[%s]", GetErrorMessage(r));
+
r = UpdateUiPanelIcon();
//TryReturnVoid(r == E_SUCCESS, "UpdateUiPanelIcon() fail[%s]", GetErrorMessage(r));
}
{
AppLogDebug("SECONDARY -> PRIMARY");
int primaryFlashValue = FLASH_MODE_OFF;
+
+ r = _pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
+ TryReturnVoid(r == E_SUCCESS, "Reg setValue fail[%s]", GetErrorMessage(r));
+
r = ToggleCameraDirection(CAMCORDER_FORM_PRIMARY_MODE);
TryReturnVoid(r == E_SUCCESS, "ToggleCameraDirection() fail[%s]", GetErrorMessage(r));
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
- __pCamcorderPresentationModel->GetValue(FLASH_MODE_PRIMARY, primaryFlashValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ _pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, primaryFlashValue);
if (value == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->SetValue(FLASH_MODE_PRIMARY, primaryFlashValue);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, primaryFlashValue);
TryReturnVoid(r == E_SUCCESS, "Reg setValue fail[%s]", GetErrorMessage(r));
}
else
AppLogDebug("CAMERA_PRIMARY_SUPPORT_FLASH is not support");
}
- r = __pCamcorderPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
- TryReturnVoid(r == E_SUCCESS, "Reg setValue fail[%s]", GetErrorMessage(r));
r = UpdateUiPanelIcon();
bool brighnesstValue = false;
int selfPortraitEnable = 0;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to Get value to registry[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(EXPOSURE_VALUE, exposure);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, exposure);
TryReturnVoid(r == E_SUCCESS, "exposure Faled to Get value to registry[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->SetExposure(exposure);
+ _pCameraPresentationModel->SetExposure(exposure);
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(BRIGHTNESS_VALUE, brightness);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, brightness);
TryReturnVoid(r == E_SUCCESS, "brightness Faled to Get value to registry[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->SetBrightness(brightness);
+ _pCameraPresentationModel->SetBrightness(brightness);
}
}
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
}
if (r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(ISO_VALUE, isoIndex);
+ r = _pCameraPresentationModel->GetValue(ISO_VALUE, isoIndex);
TryReturnVoid(r == E_SUCCESS, "isoIndex Faled to Get value to registry[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->SetIsoLevel((CameraIsoLevel)isoIndex);
+ _pCameraPresentationModel->SetIsoLevel((CameraIsoLevel)isoIndex);
}
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
if (r == E_SUCCESS)
{
- r =__pCamcorderPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, wbIndex);
+ AppLogDebug("Ravi: primary mode wb is set");
+ r =_pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, wbIndex);
TryReturnVoid(r == E_SUCCESS, "WB Faled to Get value to registry[%s]", GetErrorMessage(r));
}
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
if (r == E_SUCCESS)
{
- r =__pCamcorderPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, wbIndex);
+ AppLogDebug("Ravi: secondary mode wb is set");
+ r =_pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, wbIndex);
TryReturnVoid(r == E_SUCCESS, "WB Faled to Get value to registry[%s]", GetErrorMessage(r));
}
}
- __pCamcorderPresentationModel->SetWhiteBalance((CameraWhiteBalance)wbIndex);
+ _pCameraPresentationModel->SetWhiteBalance((CameraWhiteBalance)wbIndex);
AppLogDebug("EXIT");
}
}
}
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (entryName.Equals(String(EXPOSURE_VALUE)))
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(EXPOSURE_VALUE, currentEntryValue);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, currentEntryValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(BRIGHTNESS_VALUE, currentEntryValue);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, currentEntryValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
}
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->SetValue(EXPOSURE_VALUE, adjustEntryValue);
+ r = _pCameraPresentationModel->SetValue(EXPOSURE_VALUE, adjustEntryValue);
TryCatch(r == E_SUCCESS, , "etValue() fail[%s]", GetErrorMessage(r));
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->SetValue(BRIGHTNESS_VALUE, adjustEntryValue);
+ r = _pCameraPresentationModel->SetValue(BRIGHTNESS_VALUE, adjustEntryValue);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
}
}
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- __pCamcorderPresentationModel->SetExposure(adjustEntryValue);
+ _pCameraPresentationModel->SetExposure(adjustEntryValue);
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- __pCamcorderPresentationModel->SetBrightness(adjustEntryValue);
+ _pCameraPresentationModel->SetBrightness(adjustEntryValue);
}
else
{
TryCatch(__pCameraInfoPanel != null, r = E_FAILURE, "__pCameraInfoPanel is null");
- __closeTimerValue = 0;
- __pExposureCloseTimer = new (std::nothrow) Timer();
- __pExposureCloseTimer->Construct(*this);
+ _closeTimerValue = 0;
+ _pExposureCloseTimer = new (std::nothrow) Timer();
+ _pExposureCloseTimer->Construct(*this);
- r = __pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
+ r = _pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
TryCatch(r == E_SUCCESS, , "Timer::start fail[%s]", GetErrorMessage(r));
__pCameraInfoPanel->SetDrawExposure(true);
return r;
CATCH:
- delete __pExposureCloseTimer;
- __pExposureCloseTimer = null;
+ delete _pExposureCloseTimer;
+ _pExposureCloseTimer = null;
return r;
}
bool exposureValue = false;
bool brighnesstValue = false;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "exposure Faled to Get value to registry[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(EXPOSURE_VALUE, exposure);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, exposure);
TryCatch(r == E_SUCCESS, , "exposure Faled to Get value to registry[%s]", GetErrorMessage(r));
AppLogDebug("Exposure value %d", exposure);
}
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(BRIGHTNESS_VALUE, exposure);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, exposure);
TryCatch(r == E_SUCCESS, , "exposure Faled to Get value to registry[%s]", GetErrorMessage(r));
AppLogDebug("Exposure value %d",exposure);
}
bool exposureValue = false;
bool brighnesstValue = false;
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "GetValue() fail(%s)", GetErrorMessage(r));
- if (__pExposureCloseTimer->Cancel() == E_SUCCESS)
+ if (_pExposureCloseTimer->Cancel() == E_SUCCESS)
{
HidePopup();
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
int guideLineEnable = DISABLE_GUIDELINE;
String listName = L"";
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("OnOrientationChanged >> TerminateApp Execution");
{
__isOrientationChanged = true;
- if (__pAppTimer != null)
+ if (_pAppTimer != null)
{
- __pAppTimer->Cancel();
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
}
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
SetOverlayPanelOrientationChanged(orientationStatus);
__dir = orientationStatus;
- __pCamcorderPresentationModel->SetOrientation(__dir);
+ _pCameraPresentationModel->SetOrientation(__dir);
if (__screenMode == SCREEN_MODE_FULL)
{
- if (__pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING || __isRecording == true)
+ if (_pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING || _isRecording == true)
{
HidePanel(true, true);
}
}
}
- r = __pCamcorderPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
TryReturnVoid(r == E_SUCCESS, "Read Reg fail[%s]", GetErrorMessage(r));
if (guideLineEnable == DISABLE_GUIDELINE)
OnHelpCloseTimerExpired();
// Update(true);
- if (__isRecording || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ if (_isRecording || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
{
- if (__pHelpCloseTimer)
+ if (_pHelpCloseTimer)
{
- __pHelpCloseTimer->Cancel();
+ _pHelpCloseTimer->Cancel();
- delete __pHelpCloseTimer;
- __pHelpCloseTimer = null;
+ delete _pHelpCloseTimer;
+ _pHelpCloseTimer = null;
}
HideScreenOverlayHelp();
}
else
{
- if (__isRecording == false)
+ if (_isRecording == false)
{
if (remainedNum > STORAGE_VALUE_ZERO && remainedNum <= STORAGE_DISPLAY_PLACE)
{
}
else
{
- AppLogDebug("__isRecording = true");
+ AppLogDebug("_isRecording = true");
}
}
Dimension dim;
BufferInfo bufferinfo;
- r = __pCamcorderPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_RECORD);
+ r = _pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_RECORD);
TryReturnVoid(r == E_SUCCESS, "SetMode() failed:%s", GetErrorMessage(r));
- dim = __pCamcorderPresentationModel->GetPreviewResolution();
+ dim = _pCameraPresentationModel->GetPreviewResolution();
AppLogDebug("CamcorderForm::GetPreviewResolution(W:%d, H:%d)", dim.width, dim.height);
__previewResolutionWidth = dim.width;
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "GetBackgroundBufferInfo() fail(%s)", GetErrorMessage(r));
- __pCamcorderPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCamcorderPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
previewResolutionSize = __previewResolutionWidth * __previewResolutionHeight;
{
if (__screenMode != mode)
{
- TryCatch(__pAppTimer != null, r = E_SYSTEM, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryCatch(_pAppTimer != null, r = E_SYSTEM, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
- __pCamcorderPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
}
SetOverlayPanelNormalMode(true);
{
if (__screenMode != mode)
{
- TryCatch(__pAppTimer != null, r = E_SYSTEM, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryCatch(_pAppTimer != null, r = E_SYSTEM, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
- __pCamcorderPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
}
SetOverlayPanelWideMode(true);
currentPosition.y = (H_PREVIEW_OVERLAY_LANDSCAPE / DIVIDE_BY_TWO);
}
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Reg getValue fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
}
if (focusSupport == true && r == E_SUCCESS)
result r = E_SUCCESS;
int timerIntervalVale = 0;
- r = __pCamcorderPresentationModel->GetValue(TIMER_INTERVAL, timerIntervalVale);
+ r = _pCameraPresentationModel->GetValue(TIMER_INTERVAL, timerIntervalVale);
TryReturnVoid(r == E_SUCCESS, "Reg getValue fail[%s]", GetErrorMessage(r));
InitMakerFocusTimer();
__pCameraInfoPanel->Invalidate(true);
- __pMakerFocusTimer->Cancel();
+ _pMakerFocusTimer->Cancel();
- __pMakerFocusTimer->Start(CAMCORDER_TIMER_ONE_SEC);
+ _pMakerFocusTimer->Start(CAMCORDER_TIMER_ONE_SEC);
__pCameraInfoPanel->CheckAvailableStorageSpace();
__pCameraInfoPanel->SetDrawIndicator(true);
__pCameraInfoPanel->Invalidate(true);
- if (__pMakerFocusTimer)
+ if (_pMakerFocusTimer)
{
- __pMakerFocusTimer->Cancel();
+ _pMakerFocusTimer->Cancel();
}
- __isRecording = false;
+ _isRecording = false;
- __isRecordingPause = false;
+ _isRecordingPause = false;
- AppLogDebug("StopRecord::GetRecorderState() = %d", __pCamcorderPresentationModel->GetRecorderState());
- if (__pCamcorderPresentationModel->GetRecorderState()== RECORDER_STATE_RECORDING
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_STARTING
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSING
+ AppLogDebug("StopRecord::GetRecorderState() = %d", _pCameraPresentationModel->GetRecorderState());
+ if (_pCameraPresentationModel->GetRecorderState()== RECORDER_STATE_RECORDING
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_STARTING
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSING
)
{
- r = __pCamcorderPresentationModel->StopRecord();
+ r = _pCameraPresentationModel->StopRecord();
TryCatch(r == E_SUCCESS, , "Stop record failed [%s]",GetErrorMessage(r));
}
r = SetRecordButton(false);
TryReturnVoid(r == E_SUCCESS, "SetRecordButton() fail[%s]", GetErrorMessage(r));
- __timeCount = 0;
+ _timeCount = 0;
- if (__pIntervalValueTimer)
+ if (_pIntervalValueTimer)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __pPopupTimer->Cancel();
+ _pPopupTimer->Cancel();
}
if (__pCameraInfoPanel->GetDrawPopupTimer() == true)
return;
CATCH:
AppLogDebug("Caught record stop exception. Terminating app");
-__pCamcorderPresentationModel->SetRecordStopException(true);
-__pCamcorderPresentationModel->CancelRecord();
+_pCameraPresentationModel->SetRecordStopException(true);
+_pCameraPresentationModel->CancelRecord();
TerminateApp();
}
r = SetRecordPauseButton(true);
TryCatch(r == E_SUCCESS, , "SetRecordPauseButton start fail[%s]", GetErrorMessage(r));
- __isRecording = false;
+ _isRecording = false;
- __isRecordingPause = true;
+ _isRecordingPause = true;
- __pCamcorderPresentationModel->PauseRecord();
+ _pCameraPresentationModel->PauseRecord();
__pRecordTimer->Cancel();
- __timeCount = 0;
+ _timeCount = 0;
r = DrawPauseRecord();
TryCatch(r == E_SUCCESS, , "DrawPauseRecord start fail[%s]", GetErrorMessage(r));
__pCameraInfoPanel->SetDrawIndicator(true);
__pCameraInfoPanel->Invalidate(true);
- if (__pMakerFocusTimer)
+ if (_pMakerFocusTimer)
{
- __pMakerFocusTimer->Cancel();
+ _pMakerFocusTimer->Cancel();
}
- __isRecording = false;
+ _isRecording = false;
- __pCamcorderPresentationModel->SetCancelRecord(true);
+ _pCameraPresentationModel->SetCancelRecord(true);
- AppLogDebug("StopRecord::GetRecorderState() = %d", __pCamcorderPresentationModel->GetRecorderState());
- if (__pCamcorderPresentationModel->GetRecorderState()== RECORDER_STATE_RECORDING
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_STARTING
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSING
+ AppLogDebug("StopRecord::GetRecorderState() = %d", _pCameraPresentationModel->GetRecorderState());
+ if (_pCameraPresentationModel->GetRecorderState()== RECORDER_STATE_RECORDING
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_STARTING
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSING
)
{
- __pCamcorderPresentationModel->StopRecord();
+ _pCameraPresentationModel->StopRecord();
}
r = DrawRecord(false);
r = SetRecordButton(false);
TryReturnVoid(r == E_SUCCESS, "SetRecordButton() fail[%s]", GetErrorMessage(r));
- __timeCount = 0;
+ _timeCount = 0;
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __pPopupTimer->Cancel();
+ _pPopupTimer->Cancel();
}
if (__pCameraInfoPanel->GetDrawPopupTimer() == true)
CamcorderForm::CancelTimerIntervalRecord(void)
{
AppLogDebug("ENTER");
- if (__pIntervalValueTimer)
+ if (_pIntervalValueTimer)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
__doRecording = false;
__pCameraInfoPanel->Show();
__setTimerInterval = false;
- __pCamcorderPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
HideUiPanel(false);
AppLogDebug("EXIT");
HideUiPanel(false);
- __isRecording = false;
+ _isRecording = false;
__doRecording = false;
- __isRecordingPause = false;
+ _isRecordingPause = false;
DrawThumbnail();
__pCameraInfoPanel->SetDrawIndicator(true);
__pCameraInfoPanel->Invalidate(true);
- if (__pMakerFocusTimer)
+ if (_pMakerFocusTimer)
{
- __pMakerFocusTimer->Cancel();
+ _pMakerFocusTimer->Cancel();
}
- __isRecording = false;
+ _isRecording = false;
- __isRecordingPause = false;
+ _isRecordingPause = false;
r = DrawRecord(false);
TryReturnVoid(r == E_SUCCESS, "DrawRecord() fail[%s]", GetErrorMessage(r));
r = SetRecordButton(false);
TryReturnVoid(r == E_SUCCESS, "SetRecordButton() fail[%s]", GetErrorMessage(r));
- __timeCount = 0;
+ _timeCount = 0;
- if (__pIntervalValueTimer)
+ if (_pIntervalValueTimer)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __pPopupTimer->Cancel();
+ _pPopupTimer->Cancel();
}
if (__pCameraInfoPanel->GetDrawPopupTimer() == true)
HideRecLabe();
- __pCamcorderPresentationModel->CloseRecord();
+ _pCameraPresentationModel->CloseRecord();
AppLogDebug("EXIT");
}
__pCameraInfoPanel->SetDrawIndicator(true);
__pCameraInfoPanel->Invalidate(true);
- if (__pMakerFocusTimer)
+ if (_pMakerFocusTimer)
{
- __pMakerFocusTimer->Cancel();
+ _pMakerFocusTimer->Cancel();
}
- __isRecording = false;
+ _isRecording = false;
EndRecordTimer();
r = SetRecordButton(false);
TryReturnVoid(r == E_SUCCESS, "SetRecordButton() fail[%s]", GetErrorMessage(r));
- __timeCount = 0;
+ _timeCount = 0;
- if (__pIntervalValueTimer)
+ if (_pIntervalValueTimer)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __pPopupTimer->Cancel();
+ _pPopupTimer->Cancel();
}
if (__pCameraInfoPanel->GetDrawPopupTimer() == true)
CamcorderForm::HideUiAction(void)
{
AppLogDebug("ENTER");
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __pPopupTimer->Cancel();
+ _pPopupTimer->Cancel();
}
if (__pCameraInfoPanel->GetDrawPopupTimer() == true)
__pCameraInfoPanel->Invalidate(true);
}
- if (__pExposureCloseTimer != null)
+ if (_pExposureCloseTimer != null)
{
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
if (__pCameraInfoPanel->GetDrawExposure() == true)
Invalidate(true);
}
- if (__pMakerFocusTimer != null)
+ if (_pMakerFocusTimer != null)
{
- __pMakerFocusTimer->Cancel();
+ _pMakerFocusTimer->Cancel();
}
AppLogDebug("EXIT");
}
{
AppLogDebug("pArguments is null");
- if (__doRecording || __isRecording || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ if (__doRecording || _isRecording || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
{
AppLogDebug("Recording");
if (__pCameraIconLabel)
if (pAllowSwitch->Equals(ALLOW_SWITCH_TRUE, false) == true)
{
AppLogDebug("ALLOW_SWITCH_TRUE");
- if (__doRecording || __isRecording || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
+ if (__doRecording || _isRecording || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_RECORDING)
{
AppLogDebug("Recording");
result r = E_SUCCESS;
int timerIntervalVale = 0;
- r = __pCamcorderPresentationModel->GetValue(TIMER_INTERVAL, timerIntervalVale);
+ r = _pCameraPresentationModel->GetValue(TIMER_INTERVAL, timerIntervalVale);
TryReturnVoid(r == E_SUCCESS, "Reg getValue fail[%s]", GetErrorMessage(r));
__pFlashButton->SetShowState(false);
int selfPortraitEnable = 0;
bool focusSupport = false;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Reg getValue fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
}
if (focusSupport == true && r == E_SUCCESS)
__pCameraInfoPanel->SetDrawMarkerFocus(false);
__pCameraInfoPanel->Invalidate(true);
}
- __pCamcorderPresentationModel->SetAutoFocusPoint(currentPosition);
+ _pCameraPresentationModel->SetAutoFocusPoint(currentPosition);
AppLogDebug("EXIT");
}
int loopCount = 0;
result r = E_SUCCESS;
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __timeCount = 0;
- __pPopupTimer->Cancel();
+ _timeCount = 0;
+ _pPopupTimer->Cancel();
}
HidePopup();
ArrayList* pContentPathList = new (std::nothrow) ArrayList(SingleObjectDeleter);
pContentPathList->Construct();
- pContentPathList = __pCamcorderPresentationModel->GetContentPathListN(CameraPresentationModel::CAMERA_MODE_RECORD);
+ pContentPathList = _pCameraPresentationModel->GetContentPathListN(CameraPresentationModel::CAMERA_MODE_RECORD);
if (pContentPathList == null)
{
delete pExtraData;
return;
}
- loopCount = __pCamcorderPresentationModel->GetContentCount();
+ loopCount = _pCameraPresentationModel->GetContentCount();
for (index = 0; index < loopCount; ++index)
{
filePath = static_cast<const String*>(pContentPathList->GetAt(index));
__isLockScreenMode = false;
- __pCamcorderPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
StartInitAppTimer();
StartInitChargingTimer();
- r = __pCamcorderPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_RECORD);
+ r = _pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_RECORD);
TryReturnVoid(r == E_SUCCESS, "SetMode() failed:%s", GetErrorMessage(r));
Update(false);
- dim = __pCamcorderPresentationModel->GetPreviewResolution();
+ dim = _pCameraPresentationModel->GetPreviewResolution();
AppLogDebug("CamcorderForm::GetPreviewResolution(W:%d, H:%d)", dim.width, dim.height);
__previewResolutionWidth = dim.width;
__previewResolutionHeight = dim.height;
- dim = __pCamcorderPresentationModel->GetRecordingResolution();
+ dim = _pCameraPresentationModel->GetRecordingResolution();
AppLogDebug("CamcorderForm::GetPreviewResolution(W:%d, H:%d)", dim.width, dim.height);
__pRecordingResolutionWidth = dim.width;
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "GetBackgroundBufferInfo fail[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCamcorderPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
previewResolutionSize = __previewResolutionWidth * __previewResolutionHeight;
__pCameraInfoPanel->SetDrawIndicator(true);
__pCameraInfoPanel->Invalidate(true);
- if (__pMakerFocusTimer)
+ if (_pMakerFocusTimer)
{
- __pMakerFocusTimer->Cancel();
+ _pMakerFocusTimer->Cancel();
}
- if (__pCamcorderPresentationModel->GetRecorderState()== RECORDER_STATE_RECORDING
- || __pCamcorderPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED)
+ if (_pCameraPresentationModel->GetRecorderState()== RECORDER_STATE_RECORDING
+ || _pCameraPresentationModel->GetRecorderState() == RECORDER_STATE_PAUSED)
{
- __pCamcorderPresentationModel->StopRecord();
+ _pCameraPresentationModel->StopRecord();
- r = __pCamcorderPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
+ r = _pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
TryReturnVoid(r == E_SUCCESS, "Reg getValue fail[%s]", GetErrorMessage(r));
if (flashMode == FLASH_MODE_ON)
{
- __pCamcorderPresentationModel->SetFlashMode(CAMERA_FLASH_MODE_ON);
+ _pCameraPresentationModel->SetFlashMode(CAMERA_FLASH_MODE_ON);
}
}
__pCameraInfoPanel->Invalidate(true);
}
- __timeCount = 0;
- __isRecording = false;
+ _timeCount = 0;
+ _isRecording = false;
__setTimerInterval = false;
- __pCamcorderPresentationModel->SetIntervalTimerRun(false);
- __isRecordingPause = false;
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
+ _isRecordingPause = false;
r = SetRecordButton(false);
AppLogDebug("SetRecordButton() fail[%s]", GetErrorMessage(r));
- if (__pIntervalValueTimer)
+ if (_pIntervalValueTimer)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __pPopupTimer->Cancel();
+ _pPopupTimer->Cancel();
}
if (__pCameraInfoPanel->GetDrawPopupTimer() == true)
__pCameraInfoPanel->Invalidate(true);
}
- if (__pChargingCompletedTimer != null)
+ if (_pChargingCompletedTimer != null)
{
- __chargingCount = 0;
- __blinkCount = 0;
- __pChargingCompletedTimer->Cancel();
+ _chargingCount = 0;
+ _blinkCount = 0;
+ _pChargingCompletedTimer->Cancel();
}
- if (__pPreviewFailPopupTimer != null)
+ if (_pPreviewFailPopupTimer != null)
{
- __pPreviewFailPopupTimer->Cancel();
+ _pPreviewFailPopupTimer->Cancel();
}
__pCameraInfoPanel->SetDrawMarkerFocus(false);
__pCameraInfoPanel->Invalidate(true);
HidePopup();
- __pCamcorderPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
- __pCamcorderPresentationModel->StopCamera();
- __pCamcorderPresentationModel->KeepScreenOnState(false, true);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->KeepScreenOnState(false, true);
AppLogDebug("EXIT");
}
{
case MSGBOX_RESULT_CLOSE:
{
- __pCamcorderPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
+ _pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
- r = __pCamcorderPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
+ r = _pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
AppLogDebug("SetValue fail [%s]", GetErrorMessage(r));
r = TerminateApp();
AppLogDebug("EXIT");
}
-void
-CamcorderForm::ShowUnlaunchPopup(void)
-{
- AppLogDebug("ENTER");
- int modalResult = 0;
- MessageBox msgBox;
- String tmpString;
- AppResource* pAppResource = null;
- result r = E_SUCCESS;
-
- pAppResource = Application::GetInstance()->GetAppResource();
- TryReturnVoid(pAppResource != null, "Failed to allocate memory for pAppResource");
-
- pAppResource->GetString(L"IDS_CAM_POP_UNABLE_TO_START_CAMERA_DURING_CALL", tmpString);
-
- r = msgBox.Construct(L"", tmpString, MSGBOX_STYLE_NONE, MESSAGEBOX_DISPLAY_TIME_3_SEC);
- TryReturnVoid(r == E_SUCCESS, "msgBox::Construct() failed by [%d]", GetErrorMessage(r));
- msgBox.ShowAndWait(modalResult);
-
- __pCamcorderPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
-
- r = TerminateApp();
- AppLogDebug("TerminateApp fail [%s]", GetErrorMessage(r));
- AppLogDebug("EXIT");
-}
-
-void
-CamcorderForm::ShowLowBatteryPopup(void)
-{
- AppLogDebug("ENTER");
- int modalResult = 0;
- MessageBox msgBox;
- String tmpString;
- AppResource* pAppResource = null;
- result r = E_SUCCESS;
-
- pAppResource = Application::GetInstance()->GetAppResource();
- TryReturnVoid(pAppResource != null, "Failed to allocate memory for pAppResource");
-
- pAppResource->GetString(L"IDS_COM_BODY_LOW_BATTERY", tmpString);
-
- r = msgBox.Construct(L"", tmpString, MSGBOX_STYLE_NONE, MESSAGEBOX_DISPLAY_TIME_3_SEC);
- TryReturnVoid(r == E_SUCCESS, "msgBox::Construct() failed by [%s]", GetErrorMessage(r));
- msgBox.ShowAndWait(modalResult);
-
- switch (modalResult)
- {
- case MSGBOX_RESULT_CLOSE:
- {
- AppLogDebug("MSGBOX_RESULT_CLOSE");
- __pCamcorderPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
-
- r = TerminateApp();
- AppLogDebug("TerminateApp fail [%s]", GetErrorMessage(r));
- }
- break;
-
- default:
- break;
- }
- AppLogDebug("EXIT");
-}
-
result
CamcorderForm::SetScreenOverlayHelpTimer(void)
{
result r = E_SUCCESS;
int overlayHelpEnable = 0;
- r = __pCamcorderPresentationModel->GetValue(OVERLAY_HELP_ENABLE, overlayHelpEnable);
+ r = _pCameraPresentationModel->GetValue(OVERLAY_HELP_ENABLE, overlayHelpEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("SetScreenOverlayHelpTimer : overlayHelpEnable = %d", overlayHelpEnable);
if (overlayHelpEnable == SCREEN_OVERLAY_HELP_ENABLE)
{
- __pHelpCloseTimer = new (std::nothrow) Timer();
- __pHelpCloseTimer->Construct(*this);
+ _pHelpCloseTimer = new (std::nothrow) Timer();
+ _pHelpCloseTimer->Construct(*this);
- r = __pHelpCloseTimer->Start(MESSAGEBOX_DISPLAY_TIME_3_SEC);
+ r = _pHelpCloseTimer->Start(MESSAGEBOX_DISPLAY_TIME_3_SEC);
TryCatch(r == E_SUCCESS, , "Timer::start fail[%s]", GetErrorMessage(r));
}
return r;
CATCH:
- delete __pHelpCloseTimer;
- __pHelpCloseTimer = null;
+ delete _pHelpCloseTimer;
+ _pHelpCloseTimer = null;
AppLogDebug("EXIT - CATCH");
return r;
TryCatch(__pHelpGoToPreviousScreen != null, r = E_FAILURE, "__pHelpGoToPreviousScreen is null");
TryCatch(__pHelpGoToPreviousScreenText != null, r = E_FAILURE, "__pHelpGoToPreviousScreenText is null");
- r = __pCamcorderPresentationModel->GetValue(OVERLAY_HELP_ENABLE, overlayHelpEnable);
+ r = _pCameraPresentationModel->GetValue(OVERLAY_HELP_ENABLE, overlayHelpEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("DrawScreenOverlayHelp : overlayHelpEnable = %d", overlayHelpEnable);
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
if (__pListViewGeneralTabMainMenu)
{
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMCORDER_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
if (__pListViewCamcoderTabMainMenu)
{
{
timeCnt = __recordTimeCount;
- if (__isRecording == true)
+ if (_isRecording == true)
{
if (IsControlAlwaysOnTop(__pRecLabelRed) == false)
{
String maxTime = L"";
String recSize = L"";
- if (__isRecording == true || __isRecordingPause == true)
+ if (_isRecording == true || _isRecordingPause == true)
{
TryCatch(__pElapsedTimeLable != null, r = E_FAILURE, "__pElapsedTimeLable is null");
TryCatch(__pElapsedTimeMaxLable != null, r = E_FAILURE, "__pElapsedTimeMaxLable is null");
TryCatch(__pElapsedRecordSizeLable != null, r = E_SYSTEM, "__pElapsedRecordSizeLable is null");
timeCnt = __recordTimeCount;
- recordedSize = __pCamcorderPresentationModel->GetRecordingSize();
+ recordedSize = _pCameraPresentationModel->GetRecordingSize();
recSizeMB = recordedSize / DIVIDE_THOUSAND;
recMin = (timeCnt % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE;
__pElapsedRecordSizeLable->SetText(recSize);
__pElapsedRecordSizeLable->SetTextColor(Color::GetColor(COLOR_ID_WHITE));
- if (__isRecording == true)
+ if (_isRecording == true)
{
if (IsControlAlwaysOnTop(__pElapsedTimeLable) == false)
{
{
int selfPortraitEnable = 0;
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (__pRecordingResolutionList)
r = pItem->Construct(Dimension(itemWidth, H_SETTING_MENU_ITEM), LIST_ANNEX_STYLE_NORMAL);
TryCatch(r == E_SUCCESS,,"Failed to construct CustomItem");
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
elementId = (index * MENU_TWO_ELEMENT);
{
if (index == CAMCORDER_SUB_MENU_CONTENT_RECORDING_RESOLUTION_MODE)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_RECORDING_RESOLUTION);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_RECORDING_RESOLUTION);
if (r == E_SUCCESS)
{
if (__pRecordingResolutionList != null)
{
if (index == CAMCORDER_SUB_MENU_CONTENT_RECORDING_RESOLUTION_MODE)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_RECORDING_RESOLUTION);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_RECORDING_RESOLUTION);
if (r == E_SUCCESS)
{
if (__pRecordingResolutionList != null)
{
int storageType = STORAGE_TYPE_PHONE;
- r = __pCamcorderPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
- if (storageType == STORAGE_TYPE_MEMORYCARD && __pCamcorderPresentationModel->IsStorageCardMounted() == false)
+ if (storageType == STORAGE_TYPE_MEMORYCARD && _pCameraPresentationModel->IsStorageCardMounted() == false)
{
- r = __pCamcorderPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
}
if (index == CAMCORDER_SUB_MENU_CONTENT_RECORDING_RESOLUTION_MODE)
}
else
{
- r = __pCamcorderPresentationModel->GetValue(arrRegStringSupport[index], regVal);
+ r = _pCameraPresentationModel->GetValue(arrRegStringSupport[index], regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
{
if (index == CAMCORDER_SUB_MENU_CONTENT_RECORDING_RESOLUTION_MODE)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_RECORDING_RESOLUTION);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_RECORDING_RESOLUTION);
if (r == E_SUCCESS)
{
{
if (index == CAMCORDER_SUB_MENU_CONTENT_RECORDING_RESOLUTION_MODE)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_RECORDING_RESOLUTION);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_RECORDING_RESOLUTION);
if (r == E_SUCCESS)
{
if (__pRecordingResolutionList != null)
{
int regVal = 0;
- r = __pCamcorderPresentationModel->GetValue(RECORDING_MODE, regVal);
+ r = _pCameraPresentationModel->GetValue(RECORDING_MODE, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
strTmp = __pSettingMenuString[index][regVal + INDEX_UNIT_ONE];
pItem->Construct(Dimension(itemWidth, H_SETTING_MENU_ITEM), LIST_ANNEX_STYLE_NORMAL);
TryCatch(r == E_SUCCESS, , "Failed to construct CustomItem");
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
elementId = (index * MENU_TWO_ELEMENT);
bool value = false;
int storageType = STORAGE_TYPE_PHONE;
- __pCamcorderPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
- if (storageType == STORAGE_TYPE_MEMORYCARD && __pCamcorderPresentationModel->IsStorageCardMounted() == false)
+ if (storageType == STORAGE_TYPE_MEMORYCARD && _pCameraPresentationModel->IsStorageCardMounted() == false)
{
- r = __pCamcorderPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
- __pCamcorderPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
}
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, value);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, value);
}
if (value == true && r == E_SUCCESS)
{
- r = __pCamcorderPresentationModel->GetValue(arrRegStringSupporExposure[index], regVal);
+ r = _pCameraPresentationModel->GetValue(arrRegStringSupporExposure[index], regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, value);
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, value);
}
- r = __pCamcorderPresentationModel->GetValue(arrRegStringSupporExposure[index], regVal);
+ r = _pCameraPresentationModel->GetValue(arrRegStringSupporExposure[index], regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
pAppResource = Application::GetInstance()->GetAppResource();
TryCatch(pAppResource != null, , "pAppResource is null");
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue Reg Fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
{
AppLogDebug("CAMERA_PRIMARY_SUPPORT_FLASH is not support");
- r = __pCamcorderPresentationModel->GetValue(FLASH_MODE_SECONDARY, flashMode);
+ r = _pCameraPresentationModel->GetValue(FLASH_MODE_SECONDARY, flashMode);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (flashMode != FLASH_MODE_OFF)
{
- r = __pCamcorderPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
TryCatch(r == E_SUCCESS, , "SetValue Reg Fail[%s]", GetErrorMessage(r));
}
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
{
AppLogDebug("CAMERA_PRIMARY_SUPPORT_FLASH is not support");
- r = __pCamcorderPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
+ r = _pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (flashMode != FLASH_MODE_OFF)
{
- r = __pCamcorderPresentationModel->SetValue(FLASH_MODE_PRIMARY, FLASH_MODE_OFF);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, FLASH_MODE_OFF);
TryCatch(r == E_SUCCESS, , "SetValue Reg Fail[%s]", GetErrorMessage(r));
}
}
}
- r = __pCamcorderPresentationModel->GetValue(FLASH_MODE_PRIMARY, regVal);
+ r = _pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
switch (index)
elementId++;
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
pAppResource = Application::GetInstance()->GetAppResource();
TryCatch(pAppResource != null,,"pAppResource is null");
- r = __pCamcorderPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue Reg Fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
if (r == E_SUCCESS)
{
{
AppLogDebug("CAMERA_PRIMARY_SUPPORT_FLASH is not support");
- r =__pCamcorderPresentationModel->SetValue(WHITE_BALANCE_TYPE_SECONDARY, 0);
+ r =_pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_SECONDARY, 0);
TryCatch(r == E_SUCCESS, , "Reg SetValue() fail[%s]", GetErrorMessage(r));
}
- r = __pCamcorderPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, regVal);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
else
{
- r = __pCamcorderPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
if (r == E_SUCCESS)
{
{
AppLogDebug("CAMERA_PRIMARY_SUPPORT_FLASH is not support");
- r =__pCamcorderPresentationModel->SetValue(WHITE_BALANCE_TYPE_PRIMARY, 0);
+ r =_pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_PRIMARY, 0);
TryCatch(r == E_SUCCESS, , "Reg SetValue() fail[%s]", GetErrorMessage(r));
}
- r = __pCamcorderPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, regVal);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
pAppResource->GetString(arrString[index], tmpString);
- r = __pCamcorderPresentationModel->GetValue(TIMER_INTERVAL, regVal);
+ r = _pCameraPresentationModel->GetValue(TIMER_INTERVAL, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (index == regVal)
String str = L"";
elementId = (index * MENU_TWO_ELEMENT);
- r = __pCamcorderPresentationModel->GetValue(GUIDELINE_ENABLE, regVal);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (index == regVal)
String str = L"";
elementId = (index * MENU_TWO_ELEMENT);
- r = __pCamcorderPresentationModel->GetValue(STORAGE_TYPE, regVal);
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (index == regVal)
if (str.Equals(String(IDS_CAM_OPT_MEMORY_CARD)))
{
- if (__pCamcorderPresentationModel->IsStorageCardMounted() == false)
+ if (_pCameraPresentationModel->IsStorageCardMounted() == false)
{
r = pItem->AddElement(rectThreeTextItem, elementId, tmpString, FONT_SIZE_SETTING_SUB_MENU_ITEM, COLOR_SETTING_MENU_VALUE_DISABLE, COLOR_SETTING_MENU_VALUE_DISABLE, COLOR_SETTING_MENU_VALUE_DISABLE, true);
}
}
void
-CamcorderForm::RemoveAllEventListener(void)
-{
- AppLogDebug("ENTER");
- RemoveOrientationEventListener(*this);
- RemoveTouchEventListener(*this);
- RemoveKeyEventListener(*this);
- AppLogDebug("EXIT");
-}
-
-void
CamcorderForm::ReInitialise(void)
{
result r = E_SUCCESS;
BufferInfo bufferinfo;
- AppLogDebug("Camera State is %d",__pCamcorderPresentationModel->GetCameraState());
- AppLogDebug("Video State is %d",__pCamcorderPresentationModel->GetRecorderState());
- __pCamcorderPresentationModel->StopCamera();
+ AppLogDebug("Camera State is %d",_pCameraPresentationModel->GetCameraState());
+ AppLogDebug("Video State is %d",_pCameraPresentationModel->GetRecorderState());
+ _pCameraPresentationModel->StopCamera();
CameraApp* pApp = static_cast<CameraApp*>(UiApp::GetInstance());
if (pApp->GetAppUiState() == APP_UI_STATE_FOREGROUND)
{
- r = __pCamcorderPresentationModel->InitializeCamcorder();
+ r = _pCameraPresentationModel->InitializeCamcorder();
TryReturnVoid(r == E_SUCCESS, "InitializeCamcorder [%s]", GetErrorMessage(r));
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "__pOverlayPanel->GetBackgroundBufferInfo() fail(%s)", GetErrorMessage(r));
- __pCamcorderPresentationModel->StartPreview(&bufferinfo);
- __pCamcorderPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->SetContinuousAutoFocus();
}
}
static const int MENU_MODE_DISABLE = -1;
static const int MENU_TWO_ELEMENT = 2;
static const int MENU_THREE_ELEMENT = 3;
-static const int MESSAGEBOX_DISPLAY_TIME_2_SEC = 2000;
-static const int MESSAGEBOX_DISPLAY_TIME_3_SEC = 3000;
+
static const int UI_INDICATOR_STORAGE_FREE_SPACE_BUFFER_LEN = 2048;
static const int MULTIPLY_BY_TEN = 10;
static const int NORMAL_MODE_RATIO = 13;
};
CameraForm::CameraForm(void)
- : __pCameraPresentationModel(null)
- , __pOverlayPanel(null)
+ : __pOverlayPanel(null)
, __screenMode(SCREEN_MODE_NORMAL)
- , __pAppTimer(null)
- , __pIntervalValueTimer(null)
- , __pCaptureStartTimer(null)
- , __pPopupTimer(null)
- , __pExposureCloseTimer(null)
- , __pTouchAutoFocusTimer(null)
- , __pHelpCloseTimer(null)
- , __pChargingTimer(null)
- , __pChargingCompletedTimer(null)
- , __pPreviewFailPopupTimer(null)
, __pListViewCameraTabMainMenu(null)
, __pListViewCameraTabSubMenu(null)
, __pListViewGeneralTabMainMenu(null)
, __settingExposure(0)
, __primaryCurrentResolutionIndex(0)
, __secondaryCurrentResolutionIndex(0)
- , __timeCount(0)
- , __chargingCount(0)
- , __blinkCount(0)
, __isTimerRunning(false)
- , __closeTimerValue(0)
- , __isUsedTimerCaptured(false)
, __previewResolutionWidth(0)
, __previewResolutionHeight(0)
, __captureResolutionWidth(0)
, __pFileEventManager(null)
, __uri(L"")
, __mime(L"")
- , __appControlActionCompleted(false)
, __formStatusFrameDeattivated(false)
, __pResetPopUp(null)
, __pYes(null)
int timerInterval = 0;
String filePath = L"";
- __appControlActionCompleted = false;
+ _appControlActionCompleted = false;
__formStatusFrameDeattivated = false;
AddKeyEventListener(*this);
__deviceOrientation = __dir;
AppLogDebug("__dir = %d && __deviceOrientation = %d", __dir, __deviceOrientation);
- __pCameraPresentationModel->SetOrientation(__dir);
+ _pCameraPresentationModel->SetOrientation(__dir);
+ _pCurrentSourceForm = SOURCE_FORM_CAMERA;
InitAppTimer();
InitPreviewFailPopupTimer();
InitChargingTimer();
InitChargingCompletedTimer();
- r = __pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
if (r != E_SUCCESS)
{
storageType = STORAGE_TYPE_PHONE;
}
- if (storageType == STORAGE_TYPE_MEMORYCARD && __pCameraPresentationModel->IsStorageCardMounted() == false)
+ if (storageType == STORAGE_TYPE_MEMORYCARD && _pCameraPresentationModel->IsStorageCardMounted() == false)
{
- r = __pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
}
- r = __pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
- r = __pCameraPresentationModel->GetValue(TIMER_INTERVAL, timerInterval);
+ r = _pCameraPresentationModel->GetValue(TIMER_INTERVAL, timerInterval);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
__pCameraInfoPanel = new (std::nothrow) CameraInfoPanel();
r = __pFileEventManager->Construct(*this);
TryCatch(r == E_SUCCESS, , "__pFileEventManager Construct fail[%s]", GetErrorMessage(r));
- filePath = __pCameraPresentationModel->GetfilePath(storageType);
+ filePath = _pCameraPresentationModel->GetfilePath(storageType);
AppLogDebug("filePath %ls", filePath.GetPointer());
if (File::IsFileExist(filePath))
AppLogDebug("FileEventManager()::AddPath() fail[%s]", GetErrorMessage(r));
- r = __pCameraPresentationModel->GetValue(PRIMARY_RESOLUTION_INDEX, __primaryCurrentResolutionIndex);
- r = __pCameraPresentationModel->GetValue(SECONDARY_RESOLUTION_INDEX, __secondaryCurrentResolutionIndex);
+ r = _pCameraPresentationModel->GetValue(PRIMARY_RESOLUTION_INDEX, __primaryCurrentResolutionIndex);
+ r = _pCameraPresentationModel->GetValue(SECONDARY_RESOLUTION_INDEX, __secondaryCurrentResolutionIndex);
AppLogDebug("EXIT");
return r;
AppLogDebug("ENTER");
result r = E_SUCCESS;
- __pCameraPresentationModel->KeepScreenOnState(false, true);
+ _pCameraPresentationModel->KeepScreenOnState(false, true);
- __pCameraPresentationModel->RemovePresentationChangedEventListener(null);
+ _pCameraPresentationModel->RemovePresentationChangedEventListener(null);
__pCameraInfoPanel->SetDrawIndicatorStroageInfo(false);
RemoveAllEventListener();
- __pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
- r = __pCameraPresentationModel->SetValue(OVERLAY_HELP_ENABLE, SCREEN_OVERLAY_HELP_DISABLE);
+ r = _pCameraPresentationModel->SetValue(OVERLAY_HELP_ENABLE, SCREEN_OVERLAY_HELP_DISABLE);
AppLogDebug("SetValue Reg Fail[%s]", GetErrorMessage(r));
if (__isLockScreenMode)
__isTimerRunning = false;
- __pCameraPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
__resolutionChange = false;
__isProhibitionTouchEvent = false;
- __pCameraPresentationModel = null;
+ _pCameraPresentationModel = null;
__pCameraStarterThread = null;
__formStatusFrameDeattivated = false;
__isTimerRunning = false;
- __pCameraPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
StartInitAppTimer();
StartInitChargingTimer();
- __pCameraPresentationModel->AddPresentationChangedEventListener(*this);
+ _pCameraPresentationModel->AddPresentationChangedEventListener(*this);
- __pCameraPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
- r = __pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ r = _pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
TryReturnVoid(r == E_SUCCESS, "SetMode() failed:%s", GetErrorMessage(r));
Update();
- previewResolutionDim = __pCameraPresentationModel->GetPreviewResolution();
+ previewResolutionDim = _pCameraPresentationModel->GetPreviewResolution();
AppLogDebug("CameraForm::GetPreviewResolution(W:%d, H:%d)", previewResolutionDim.width, previewResolutionDim.height);
__previewResolutionWidth = previewResolutionDim.width;
__previewResolutionHeight = previewResolutionDim.height;
- captureResolutionDim = __pCameraPresentationModel->GetCaptureResolution();
+ captureResolutionDim = _pCameraPresentationModel->GetCaptureResolution();
__captureResolutionWidth = captureResolutionDim.width;
__captureResolutionHeight = captureResolutionDim.height;
__pCameraInfoPanel->Invalidate(true);
}
- r = __pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, regVal);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, regVal);
TryReturnVoid(r == E_SUCCESS, "Read Reg fail[%s]", GetErrorMessage(r));
if (regVal == DISABLE_GUIDELINE)
InDrawFocus();
- r = __pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ r = _pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
TryReturnVoid(r == E_SUCCESS, "Write Reg fail[%s]", GetErrorMessage(r));
MakeSettingPopupTab(false);
HidePopup();
- isInitCameraStaus = __pCameraPresentationModel->GetInitCameraStatus();
+ isInitCameraStaus = _pCameraPresentationModel->GetInitCameraStatus();
AppLogDebug("isInitCameraStaus [%d]", isInitCameraStaus);
if (isInitCameraStaus)
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "GetBackgroundBufferInfo fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
}
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
previewResolutionSize = __previewResolutionWidth * __previewResolutionHeight;
SetCameraSettingsDevice();
}
- __pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
- if (storageType == STORAGE_TYPE_MEMORYCARD && __pCameraPresentationModel->IsStorageCardMounted() == false)
+ if (storageType == STORAGE_TYPE_MEMORYCARD && _pCameraPresentationModel->IsStorageCardMounted() == false)
{
- r = __pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
- __pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
}
- batteryLevel = __pCameraPresentationModel->GetBatteryLevel();
- isCharging = __pCameraPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
if (batteryLevel == BATTERY_CRITICAL || batteryLevel == BATTERY_EMPTY)
AppLogDebug("ENTER");
__isTimerRunning = false;
- __pCameraPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
__resolutionChange = false;
HideUiSettingMenu();
- if (__isUsedTimerCaptured == true)
+ if (_isUsedTimerCaptured == true)
{
- __timeCount = 0;
+ _timeCount = 0;
- __isUsedTimerCaptured = false;
+ _isUsedTimerCaptured = false;
if (__pCameraInfoPanel->GetDrawPopupTimer() == true)
{
{
TryCatch(__pThumbnailPanel != null, , "__pThumbnailPanel is null");
- pThumbnailBitmap = __pCameraPresentationModel->GetLatestThumbnail();
+ pThumbnailBitmap = _pCameraPresentationModel->GetLatestThumbnail();
if (pThumbnailBitmap == null)
{
Bitmap* pThumbnailBitmap = null;
Bitmap* pRotateBitmap = null;
- pThumbnailBitmap = __pCameraPresentationModel->GetLatestThumbnail();
+ pThumbnailBitmap = _pCameraPresentationModel->GetLatestThumbnail();
// TryCatch(pThumbnailBitmap != null, , "pThumbnailBitmap is null");
if (pThumbnailBitmap == null)
{
}
else
{
- TryCatch(__pAppTimer != null, , "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryCatch(_pAppTimer != null, , "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryCatch(r == E_SUCCESS, , "GetBackgroundBufferInfo start fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
}
- r = __pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (guideLineEnable == DISABLE_GUIDELINE)
StopPopupTimer();
- __isUsedTimerCaptured = false;
+ _isUsedTimerCaptured = false;
Update();
AppLogDebug("CAMERA_ACTION_EVENT_TOUCH_AUTO_FOCUSED");
DrawFocus(CAMERA_FOCUS_READY);
- TryReturnVoid(__pTouchAutoFocusTimer != null, "__pTouchAutoFocusTimer is null");
- __pTouchAutoFocusTimer->Cancel();
+ TryReturnVoid(_pTouchAutoFocusTimer != null, "_pTouchAutoFocusTimer is null");
+ _pTouchAutoFocusTimer->Cancel();
- r = __pTouchAutoFocusTimer->Start(CAMERA_TIMER_2_SEC);
+ r = _pTouchAutoFocusTimer->Start(CAMERA_TIMER_2_SEC);
TryReturnVoid(r == E_SUCCESS, "Faled Start Timer[%s]", GetErrorMessage(r));
}
break;
bool isCharging = false;
BatteryLevel batteryLevel;
- __pCameraPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ _pCameraPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
- requestType = __pCameraPresentationModel->GetAppControlRequestType();
+ requestType = _pCameraPresentationModel->GetAppControlRequestType();
if (GetAppLaunchType() == APP_LAUNCH_TYPE_REQUESET && requestType == CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_SUCCEEDED)
{
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "GetBackgroundBufferInfo fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
__isProhibitionTouchEvent = true;
OnCapuredPerform();
}
- batteryLevel = __pCameraPresentationModel->GetBatteryLevel();
- isCharging = __pCameraPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
AppLogDebug("isCharging = %d", isCharging);
__pBatteryState->Show();
}
- if (__pCameraPresentationModel->GetCameraState() == CAMERA_STATE_ERROR)
+ if (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_ERROR)
{
AppLogDebug("Camera State is CAMERA_STATE_ERROR");
- __pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
- r = __pCameraPresentationModel->InitializeCamera();
+ r = _pCameraPresentationModel->InitializeCamera();
TryReturnVoid(r == E_SUCCESS, "InitializeCamera [%s]", GetErrorMessage(r));
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "__pOverlayPanel->GetBackgroundBufferInfo() fail(%s)", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->SetContinuousAutoFocus();
}
}
break;
pCameraApp->SetFrameEnabled(true);
}
- isInitCameraStaus = __pCameraPresentationModel->GetInitCameraStatus();
+ isInitCameraStaus = _pCameraPresentationModel->GetInitCameraStatus();
AppLogDebug("isInitCameraStaus = %d", isInitCameraStaus);
if (isInitCameraStaus == false)
return;
}
- if (__pCameraPresentationModel->IsCameraPoweredOn())
+ if (_pCameraPresentationModel->IsCameraPoweredOn())
{
result r = E_SUCCESS;
BufferInfo bufferinfo;
AppLogDebug("CAMERA_ACTION_EVENT_FRAME_ACTIVATED:CameraPoweredOn");
- if (__pCameraPresentationModel->GetCameraState() == CAMERA_STATE_ERROR)
+ if (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_ERROR)
{
AppLogDebug("Camera State is CAMERA_STATE_ERROR");
- __pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
- r = __pCameraPresentationModel->InitializeCamera();
+ r = _pCameraPresentationModel->InitializeCamera();
TryReturnVoid(r == E_SUCCESS, "InitializeCamcorder [%s]", GetErrorMessage(r));
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "__pOverlayPanel->GetBackgroundBufferInfo() fail(%s)", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->SetContinuousAutoFocus();
}
- batteryLevel = __pCameraPresentationModel->GetBatteryLevel();
- isCharging = __pCameraPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
GetCameraToForeground();
}
- batteryLevel = __pCameraPresentationModel->GetBatteryLevel();
- isCharging = __pCameraPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
if (batteryLevel == BATTERY_CRITICAL || batteryLevel == BATTERY_EMPTY)
__formStatusFrameDeattivated = true;
- isInitCameraStaus = __pCameraPresentationModel->GetInitCameraStatus();
+ isInitCameraStaus = _pCameraPresentationModel->GetInitCameraStatus();
AppLogDebug("isInitCameraStaus = %d", isInitCameraStaus);
if (isInitCameraStaus == false)
return;
}
- if (__pCameraPresentationModel->GetStartPreviewException())
+ if (_pCameraPresentationModel->GetStartPreviewException())
{
AppLogDebug("CAMERA_ACTION_EVENT_PREVIEW_START_FAILED");
bool isCharging = false;
BatteryLevel batteryLevel;
- batteryLevel = __pCameraPresentationModel->GetBatteryLevel();
- isCharging = __pCameraPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
AppLogDebug("batteryLevel = %d", batteryLevel);
AppLogDebug("isCharging = %d", isCharging);
{
if (batteryLevel == BATTERY_CRITICAL || batteryLevel == BATTERY_EMPTY)
{
- __pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
+ _pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
- if ((__pCameraPresentationModel->GetCameraState() == CAMERA_STATE_CAPTURING
- || __pCameraPresentationModel->GetCameraState() == CAMERA_STATE_CAPTURED)
+ if ((_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_CAPTURING
+ || _pCameraPresentationModel->GetCameraState() == CAMERA_STATE_CAPTURED)
&& __isTimerRunning == false)
{
AppLogDebug("CAPTURING or CAPTURED");
int requestType = 0;
- requestType = __pCameraPresentationModel->GetAppControlRequestType();
+ requestType = _pCameraPresentationModel->GetAppControlRequestType();
if (GetAppLaunchType() == APP_LAUNCH_TYPE_REQUESET && requestType == CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED)
{
}
else
{
- __pCameraPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ _pCameraPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
Update();
r = UpdateUiPanelIcon();
//TryCatch(r == E_SUCCESS, r = E_SYSTEM, "UpdateSetUiPanelIcon() - fail[%s]", GetErrorMessage(r));
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_COUNT, cameraCount);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_COUNT, cameraCount);
AppLogDebug("GetMediaCapability [%s]", GetErrorMessage(r));
if (cameraCount > SUPPORTED_CAMERA_NUM)
{
AppLogDebug("ENTER");
result r = E_SUCCESS;
- if (__pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW)
+ if (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW)
{
SceneManager* pSceneManager = SceneManager::GetInstance();
AppAssert(pSceneManager);
AppLogDebug("GoForward to IDSCN_CAMCORDER!!!");
- r = __pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_RECORD);
+ r = _pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_RECORD);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
r = pSceneManager->GoForward(ForwardSceneTransition(IDSCN_CAMCORDER));
|| __dir == ORIENTATION_STATUS_PORTRAIT_REVERSE)
{
r = DrawExposureSlider(currentPosition, DRAW_RELEASED);
- __closeTimerValue = UNIT_VALUE_ZERO;
+ _closeTimerValue = UNIT_VALUE_ZERO;
- TryReturnVoid(__pExposureCloseTimer != null, "__pExposureCloseTimer is null");
- __pExposureCloseTimer->Cancel();
+ TryReturnVoid(_pExposureCloseTimer != null, "_pExposureCloseTimer is null");
+ _pExposureCloseTimer->Cancel();
- r = __pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
- TryReturnVoid(r == E_SUCCESS, "__pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
+ r = _pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
+ TryReturnVoid(r == E_SUCCESS, "_pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
}
else
{
r = DrawExposureSlider(currentPosition, DRAW_RELEASED);
- __closeTimerValue = UNIT_VALUE_ZERO;
+ _closeTimerValue = UNIT_VALUE_ZERO;
- TryReturnVoid(__pExposureCloseTimer != null, "__pExposureCloseTimer is null");
- __pExposureCloseTimer->Cancel();
+ TryReturnVoid(_pExposureCloseTimer != null, "_pExposureCloseTimer is null");
+ _pExposureCloseTimer->Cancel();
- r = __pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
- TryReturnVoid(r == E_SUCCESS, "__pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
+ r = _pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
+ TryReturnVoid(r == E_SUCCESS, "_pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
}
AppLogDebug("EXIT");
}
int storageCardChageState = CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN;
String fullFileName = L"";
- if (__pCameraPresentationModel->GetLatestThumbnail() != null)
+ if (_pCameraPresentationModel->GetLatestThumbnail() != null)
{
- storageCardChageState = __pCameraPresentationModel->GetStorageCardChageState();
+ storageCardChageState = _pCameraPresentationModel->GetStorageCardChageState();
if (storageCardChageState == CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_MOUNT_TO_UNMOUNT)
{
AppLogDebug("MOUNT_TO_UNMOUNT : Don't LaunchImageview");
- __pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
- fullFileName = __pCameraPresentationModel->GetContentFilePath(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ fullFileName = _pCameraPresentationModel->GetContentFilePath(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
if (fullFileName == L"")
{
else
{
AppLogDebug("LaunchImageview");
- __pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
- fullFileName = __pCameraPresentationModel->GetContentFilePath(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ fullFileName = _pCameraPresentationModel->GetContentFilePath(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
if (fullFileName == L"")
{
AppLogDebug("ENTER");
if (__isTimerRunning == true)
{
- if (__pPopupTimer != null)
+ if (_pPopupTimer != null)
{
- __pPopupTimer->Cancel();
+ _pPopupTimer->Cancel();
- delete __pPopupTimer;
- __pPopupTimer = null;
+ delete _pPopupTimer;
+ _pPopupTimer = null;
}
- __timeCount = INDEX_UNIT_ZERO;
+ _timeCount = INDEX_UNIT_ZERO;
- if (__isUsedTimerCaptured == true)
+ if (_isUsedTimerCaptured == true)
{
__isTimerRunning = false;
- __pCameraPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
- __isUsedTimerCaptured = false;
+ _isUsedTimerCaptured = false;
- if (__pIntervalValueTimer != null)
+ if (_pIntervalValueTimer != null)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
__pCameraInfoPanel->SetDrawPopupTimerUpdate(false);
result r = E_SUCCESS;
String controlName = L"";
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("OnTouchPressed >> TerminateApp Execution");
return;
return;
}
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
if (__pCameraInfoPanel->GetDrawExposure() == true)
{
- TryReturnVoid(__pExposureCloseTimer != null, "__pExposureCloseTimer is null");
- __pExposureCloseTimer->Cancel();
+ TryReturnVoid(_pExposureCloseTimer != null, "_pExposureCloseTimer is null");
+ _pExposureCloseTimer->Cancel();
- r = __pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
- TryReturnVoid(r == E_SUCCESS, "__pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
+ r = _pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
+ TryReturnVoid(r == E_SUCCESS, "_pExposureCloseTimer start fail[%s]", GetErrorMessage(r));
}
AppLogDebug("EXIT");
}
return;
}
- if ((controlName.Equals(String(IDS_ACTION_UI_PANEL_CAPTURE_NAME))) && (__pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW))
+ if ((controlName.Equals(String(IDS_ACTION_UI_PANEL_CAPTURE_NAME))) && (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW))
{
AppLogDebug("OnTouchLongPressed Action");
if (source.Equals(*__pShutterButton) == true)
{
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
}
}
AppLogDebug("EXIT");
int checkActivePanel = -1;
bool doHidePopup = false;
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("OnTouchPressed >> TerminateApp Execution");
return;
{
if (source.Equals(*__pShutterButton) == true)
{
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
__pCameraInfoPanel->SetDrawExposure(false);
if ((doHidePopup == false) && (__pCameraInfoPanel->GetDrawExposure() == false))
{
- if ((controlName.Equals(String(IDS_CAMERA_INFO_PANEL_NAME))) && (__pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW))
+ if ((controlName.Equals(String(IDS_CAMERA_INFO_PANEL_NAME))) && (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW))
{
DrawTouchAutoFocus(currentPosition);
}
CheckGeneralSettingLabel();
}
- if ((controlName.Equals(String(IDS_ACTION_UI_PANEL_CAPTURE_NAME))) && (__pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW))
+ if ((controlName.Equals(String(IDS_ACTION_UI_PANEL_CAPTURE_NAME))) && (_pCameraPresentationModel->GetCameraState() == CAMERA_STATE_PREVIEW))
{
if (source.Equals(*__pShutterButton) == true)
{
if (controlName.Equals(String(IDS_THUMBNAIL_PANLE_NAME))
&& __pThumbnailPanel->GetShowState() == true
&& (GetAppLaunchType() != APP_LAUNCH_TYPE_REQUESET)
- && __pCameraPresentationModel->GetCameraState()!= CAMERA_STATE_CAPTURED
+ && _pCameraPresentationModel->GetCameraState()!= CAMERA_STATE_CAPTURED
)
{
if (source.Equals(*__pThumbnailPanel) == true)
String controlName = L"";
result r = E_SUCCESS;
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("OnTouchPressed >> TerminateApp Execution");
return;
{
r = DrawExposureSlider(currentPosition, DRAW_MOVED);
TryReturnVoid(r == E_SUCCESS, "DrawExposureSlider() fail[%s]", GetErrorMessage(r));
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- TryReturnVoid(__pExposureCloseTimer != null, "__pExposureCloseTimer is null");
- __pExposureCloseTimer->Cancel();
+ TryReturnVoid(_pExposureCloseTimer != null, "_pExposureCloseTimer is null");
+ _pExposureCloseTimer->Cancel();
}
}
AppLogDebug("EXIT");
DeleteTimer();
- __pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
r = SendAppControlResult(pCameraApp->GetRequestId());
TryReturnVoid(r == E_SUCCESS, "SendAppControlResult [%s]", GetErrorMessage(r));
result r = E_SUCCESS;
int timerInterval = 0;
- if (__pCaptureStartTimer)
+ if (_pCaptureStartTimer)
{
- __pCaptureStartTimer->Cancel();
+ _pCaptureStartTimer->Cancel();
}
timerInterval = GetTimerIntervalValue();
Invalidate(true);
- __isUsedTimerCaptured = true;
+ _isUsedTimerCaptured = true;
r = SetTimerIntervalValue(timerInterval);
TryReturnVoid(r == E_SUCCESS, "SetTimerIntervalValue() fail[%s]", GetErrorMessage(r));
- __timeCount = 0;
+ _timeCount = 0;
r = DrawTimerPopup();
TryReturnVoid(r == E_SUCCESS, "DrawTimerPopup() fail[%s]", GetErrorMessage(r));
CameraForm::OnTouchAutoFocusTimerExpired(void)
{
AppLogDebug("ENTER");
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
- __pTouchAutoFocusTimer->Cancel();
+ _pTouchAutoFocusTimer->Cancel();
AppLogDebug("EXIT");
}
CameraForm::OnPopupTimerExpired(void)
{
AppLogDebug("ENTER");
- if (__pCameraPresentationModel->IsPreviewState() == true)
+ if (_pCameraPresentationModel->IsPreviewState() == true)
{
- __timeCount--;
+ _timeCount--;
__pCameraInfoPanel->SetDrawPopupTimerUpdate(true);
- __pCameraInfoPanel->SetDrawPopupTimerCount(__timeCount);
+ __pCameraInfoPanel->SetDrawPopupTimerCount(_timeCount);
__pCameraInfoPanel->Invalidate(true);
- AppLogDebug("__timeCount=%d", __timeCount);
+ AppLogDebug("_timeCount=%d", _timeCount);
- if (__timeCount == INDEX_UNIT_ZERO || __timeCount == INDEX_UNIT_ONE)
+ if (_timeCount == INDEX_UNIT_ZERO || _timeCount == INDEX_UNIT_ONE)
{
StopPopupTimer();
}
bool focusSupport = false;
int selfPortraitEnable = 0;
- if (__isUsedTimerCaptured == true)
+ if (_isUsedTimerCaptured == true)
{
__pCameraInfoPanel->SetDrawPopupTimerUpdate(false);
__pBackButton->Invalidate(true);
}
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Reg getValue fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
}
if (focusSupport == true && r == E_SUCCESS)
}
}
- __pCameraPresentationModel->Capture();
+ _pCameraPresentationModel->Capture();
__isTimerRunning = false;
- __pCameraPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
if (__pBatteryState)
{
CameraForm::OnHelpCloseTimerExpired(void)
{
AppLogDebug("ENTER");
- if (__pHelpCloseTimer)
+ if (_pHelpCloseTimer)
{
- __pHelpCloseTimer->Cancel();
+ _pHelpCloseTimer->Cancel();
- delete __pHelpCloseTimer;
- __pHelpCloseTimer = null;
+ delete _pHelpCloseTimer;
+ _pHelpCloseTimer = null;
}
HideScreenOverlayHelp();
CameraForm::OnExposureCloseTimerExpired(void)
{
AppLogDebug("ENTER");
- __closeTimerValue++;
+ _closeTimerValue++;
- AppLogDebug("__closeTimerValue expire %d", __closeTimerValue);
+ AppLogDebug("_closeTimerValue expire %d", _closeTimerValue);
- if (__closeTimerValue == EXPOSURE_TIMER_IS_ALIVE)
+ if (_closeTimerValue == EXPOSURE_TIMER_IS_ALIVE)
{
if (__pCameraInfoPanel->GetDrawExposure() == true)
{
Invalidate(true);
}
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
AppLogDebug("EXIT");
}
__pBatteryState->SetPosition(X_INDICATOR_BATTERY_LANDSCAPE, Y_INDICATOR_BATTERY_LANDSCAPE);
}
- __chargingCount++;
+ _chargingCount++;
- if (__chargingCount % DIVIDE_BY_TWO)
+ if (_chargingCount % DIVIDE_BY_TWO)
{
pBitmap = ResourceManager::GetBitmapN(RESOURCE_IC_CAMERA_BATTERY_20);
}
}
TryCatch(pBitmap != null, r = E_SYSTEM, "FlashButton::pBitmap is null");
- if (__chargingCount >= BATTERY_STATE_20)
+ if (_chargingCount >= BATTERY_STATE_20)
{
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
}
- __blinkCount++;
+ _blinkCount++;
__pBatteryState->SetBackgroundBitmap(*pBitmap);
__pBatteryState->Invalidate(true);
AppLogDebug("__batteryStatus = %d", __batteryStatus);
- AppLogDebug("__chargingCount = %d", __chargingCount);
- AppLogDebug("__blinkCount = %d", __blinkCount);
+ AppLogDebug("_chargingCount = %d", _chargingCount);
+ AppLogDebug("_blinkCount = %d", _blinkCount);
delete pBitmap;
pBitmap = null;
AppLogDebug("batteryLevel = %d", batteryLevel);
- __chargingCount++;
+ _chargingCount++;
AppLogDebug("__batteryStatus = %d", __batteryStatus);
- AppLogDebug("__chargingCount = %d", __chargingCount);
+ AppLogDebug("_chargingCount = %d", _chargingCount);
- if ((__batteryStatus == BATTERY_STATE_0 || __batteryStatus == BATTERY_STATE_1) && __chargingCount == INDEX_UNIT_ONE)
+ if ((__batteryStatus == BATTERY_STATE_0 || __batteryStatus == BATTERY_STATE_1) && _chargingCount == INDEX_UNIT_ONE)
{
pBitmap = ResourceManager::GetBitmapN(RESOURCE_IC_CAMERA_BATTERY_LOW);
}
else
{
- pBitmap = ResourceManager::GetBitmapN(__batteryStatus + __chargingCount);
+ pBitmap = ResourceManager::GetBitmapN(__batteryStatus + _chargingCount);
}
TryCatch(pBitmap != null, r = E_SYSTEM, "FlashButton::pBitmap is null");
- maxChargingCnt = (static_cast<int>(__batteryStatus)) + __chargingCount;
+ maxChargingCnt = (static_cast<int>(__batteryStatus)) + _chargingCount;
AppLogDebug("maxCount = %d", maxChargingCnt);
if (maxChargingCnt >= BATTERY_STATE_20)
{
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
}
__pBatteryState->SetBackgroundBitmap(*pBitmap);
CameraForm::OnTimerExpired(Tizen::Base::Runtime::Timer& timer)
{
AppLogDebug("ENTER");
- if (timer.Equals(*__pAppTimer))
+ if (timer.Equals(*_pAppTimer))
{
- AppLogDebug("__pAppTimer");
+ AppLogDebug("_pAppTimer");
OnAppTimerExpired();
}
- else if (timer.Equals(*__pCaptureStartTimer))
+ else if (timer.Equals(*_pCaptureStartTimer))
{
- AppLogDebug("__pCaptureStartTimer");
+ AppLogDebug("_pCaptureStartTimer");
OnCaptureStartTimerExpired();
}
- else if (timer.Equals(*__pTouchAutoFocusTimer))
+ else if (timer.Equals(*_pTouchAutoFocusTimer))
{
- AppLogDebug("__pTouchAutoFocusTimer");
+ AppLogDebug("_pTouchAutoFocusTimer");
OnTouchAutoFocusTimerExpired();
}
- else if (timer.Equals(*__pPopupTimer))
+ else if (timer.Equals(*_pPopupTimer))
{
- AppLogDebug("__pPopupTimer");
+ AppLogDebug("_pPopupTimer");
OnPopupTimerExpired();
}
- else if (timer.Equals(*__pIntervalValueTimer))
+ else if (timer.Equals(*_pIntervalValueTimer))
{
- AppLogDebug("__pIntervalValueTimer");
+ AppLogDebug("_pIntervalValueTimer");
OnIntervalValueTimerExpired();
StartInitChargingTimer();
}
- else if (timer.Equals(*__pHelpCloseTimer))
+ else if (timer.Equals(*_pHelpCloseTimer))
{
AppLogDebug("__pHelpCloseTimer");
OnHelpCloseTimerExpired();
}
- else if (timer.Equals(*__pExposureCloseTimer))
+ else if (timer.Equals(*_pExposureCloseTimer))
{
- AppLogDebug("__pExposureCloseTimer");
+ AppLogDebug("_pExposureCloseTimer");
OnExposureCloseTimerExpired();
}
- else if (timer.Equals(*__pChargingTimer))
+ else if (timer.Equals(*_pChargingTimer))
{
result r = E_SUCCESS;
- AppLogDebug("__pChargingTimer");
+ AppLogDebug("_pChargingTimer");
bool isCharging = false;
__batteryStatus = GetCurrentBatteryState();
AppLogDebug("__batteryStatus = %d", __batteryStatus);
- isCharging = __pCameraPresentationModel->IsCharging();
+ isCharging = _pCameraPresentationModel->IsCharging();
if (isCharging)
{
if (__batteryStatus == BATTERY_STATE_20)
{
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
- __blinkCount = INDEX_UNIT_ZERO;
+ _blinkCount = INDEX_UNIT_ZERO;
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
StartInitChargingCompletedTimer();
}
}
else
{
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
- __blinkCount = INDEX_UNIT_ZERO;
+ _blinkCount = INDEX_UNIT_ZERO;
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
if (__batteryStatus == BATTERY_STATE_20)
{
- AppLogDebug("__pChargingTimer -> __pChargingCompletedTimer");
+ AppLogDebug("_pChargingTimer -> __pChargingCompletedTimer");
StartInitChargingCompletedTimer();
}
}
}
- else if (timer.Equals(*__pChargingCompletedTimer))
+ else if (timer.Equals(*_pChargingCompletedTimer))
{
result r = E_SUCCESS;
AppLogDebug("__pChargingCompletedTimer");
bool isCharging = false;
- isCharging = __pCameraPresentationModel->IsCharging();
+ isCharging = _pCameraPresentationModel->IsCharging();
__batteryStatus = GetCurrentBatteryState();
AppLogDebug("__batteryStatus = %d", __batteryStatus);
if (isCharging == false && __batteryStatus == BATTERY_STATE_20)
{
- if (__blinkCount == INDEX_UNIT_TWENTY)
+ if (_blinkCount == INDEX_UNIT_TWENTY)
{
AppLogDebug("__pChargingCompletedTimer cancel");
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
- __blinkCount = INDEX_UNIT_ZERO;
+ _blinkCount = INDEX_UNIT_ZERO;
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
CheckBatteryStatus();
}
{
AppLogDebug("isCharging = true >> __pChargingCompletedTimer cancel");
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
- __blinkCount = INDEX_UNIT_ZERO;
+ _blinkCount = INDEX_UNIT_ZERO;
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
CheckBatteryStatus();
}
}
- else if (timer.Equals(*__pPreviewFailPopupTimer))
+ else if (timer.Equals(*_pPreviewFailPopupTimer))
{
AppLogDebug("__pPreviewFailPopupTimer");
- __pPreviewFailPopupTimer->Cancel();
+ _pPreviewFailPopupTimer->Cancel();
- if (__pCameraPresentationModel->GetStartPreviewException())
+ if (_pCameraPresentationModel->GetStartPreviewException())
{
OnPreviewFailPopupTimerExpired();
}
__pActionPanel->AddTouchEventListener(*this);
__pActionPanel->SetName(IDS_ACTION_UI_PANEL_NAME);
- AppLogDebug("GetDisplayResolutionType = %d", __pCameraPresentationModel->GetDisplayResolutionType());
+ AppLogDebug("GetDisplayResolutionType = %d", _pCameraPresentationModel->GetDisplayResolutionType());
if (__dir == ORIENTATION_STATUS_PORTRAIT_REVERSE
|| __dir == ORIENTATION_STATUS_PORTRAIT)
{
if (clientArea.height == DISPLAY_WVGA)
{
- __pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_WVGA);
+ _pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_WVGA);
}
else
{
- __pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_HD);
+ _pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_HD);
}
}
else
{
if (clientArea.width == DISPLAY_WVGA)
{
- __pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_WVGA);
+ _pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_WVGA);
}
else
{
- __pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_HD);
+ _pCameraPresentationModel->SetDisplayResolutionType(CameraPresentationModel::DISPLAY_RESOLUTION_HD);
}
}
__pShutterButton->SetName(IDS_ACTION_UI_PANEL_CAPTURE_NAME);
__pShutterButton->AddTouchEventListener(*this);
- AppLogDebug("GetDisplayResolutionType = %d", __pCameraPresentationModel->GetDisplayResolutionType());
+ AppLogDebug("GetDisplayResolutionType = %d", _pCameraPresentationModel->GetDisplayResolutionType());
if (__dir == ORIENTATION_STATUS_PORTRAIT_REVERSE
|| __dir == ORIENTATION_STATUS_PORTRAIT)
TryCatch(__pFlashButton != null, r = E_SYSTEM, "__pFlashButton is null");
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "Read Reg Fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
{
- r = __pCameraPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
TryCatch(r == E_SUCCESS, , "SetValue Reg Fail[%s]", GetErrorMessage(r));
pBitmap = ResourceManager::GetBitmapN(RESOURCE_ID_CAMERA_MODE_FLASH_OFF_PRESS_DIM);
}
else if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
+ r = _pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
TryCatch(r == E_SUCCESS, , "Read Reg Fail[%s]", GetErrorMessage(r));
switch (flashMode)
}
else
{
- r = __pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, FLASH_MODE_OFF);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, FLASH_MODE_OFF);
TryCatch(r == E_SUCCESS, , "Read Reg Fail[%s]", GetErrorMessage(r));
pBitmap = ResourceManager::GetBitmapN(RESOURCE_ID_CAMERA_MODE_FLASH_OFF_PRESS_DIM);
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
}
if (r == E_SUCCESS)
Point ptModeChangeButton;
Rectangle rectThumbnailButton;
- AppLogDebug("GetDisplayResolutionType = %d", __pCameraPresentationModel->GetDisplayResolutionType());
+ AppLogDebug("GetDisplayResolutionType = %d", _pCameraPresentationModel->GetDisplayResolutionType());
if (__dir == ORIENTATION_STATUS_PORTRAIT
|| __dir == ORIENTATION_STATUS_PORTRAIT_REVERSE)
case SETTING_TIMER_CAPTURE_2_SEC:
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
- r = __pIntervalValueTimer->Start(CAMERA_TIMER_2_SEC);
- TryCatch(r == E_SUCCESS, , "__pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
+ r = _pIntervalValueTimer->Start(CAMERA_TIMER_2_SEC);
+ TryCatch(r == E_SUCCESS, , "_pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
}
break;
case SETTING_TIMER_CAPTURE_5_SEC:
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
- r = __pIntervalValueTimer->Start(CAMERA_TIMER_5_SEC);
- TryCatch(r == E_SUCCESS, , "__pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
+ r = _pIntervalValueTimer->Start(CAMERA_TIMER_5_SEC);
+ TryCatch(r == E_SUCCESS, , "_pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
}
break;
case SETTING_TIMER_CAPTURE_10_SEC:
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
- r = __pIntervalValueTimer->Start(CAMERA_TIMER_10_SEC);
- TryCatch(r == E_SUCCESS, , "__pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
+ r = _pIntervalValueTimer->Start(CAMERA_TIMER_10_SEC);
+ TryCatch(r == E_SUCCESS, , "_pIntervalValueTimer start fail[%s]", GetErrorMessage(r));
}
break;
AppLogDebug("ENTER");
result r = E_SUCCESS;
- r = __pCameraPresentationModel->SetExifOrientation(deviceOrientation);
+ r = _pCameraPresentationModel->SetExifOrientation(deviceOrientation);
AppLogDebug("SetExifOrientation : deviceOrientation = %d, fail[%s]", deviceOrientation, GetErrorMessage(r));
AppLogDebug("EXIT");
}
{
case SETTING_TIMER_CAPTURE_0_SEC:
{
- __isUsedTimerCaptured = false;
+ _isUsedTimerCaptured = false;
__isTimerRunning = false;
- __pCameraPresentationModel->SetIntervalTimerRun(false);
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
- __pCameraPresentationModel->Capture();
+ _pCameraPresentationModel->Capture();
StartInitChargingTimer();
}
__pBatteryState->Show();
}
- __pCameraPresentationModel->SetIntervalTimerRun(true);
+ _pCameraPresentationModel->SetIntervalTimerRun(true);
HideUiPanel(true);
__pCameraInfoPanel->Invalidate(true);
}
- if (__isUsedTimerCaptured == false)
+ if (_isUsedTimerCaptured == false)
{
- __pCaptureStartTimer->Cancel();
+ _pCaptureStartTimer->Cancel();
__pCameraInfoPanel->SetDrawMarkerFocus(false);
__pCameraInfoPanel->Invalidate(true);
- r = __pCaptureStartTimer->Start(CAMERA_TIMER_1_SEC);
- TryReturnVoid(r == E_SUCCESS, "__pCaptureStartTimer start fail[%s]", GetErrorMessage(r));
+ r = _pCaptureStartTimer->Start(CAMERA_TIMER_1_SEC);
+ TryReturnVoid(r == E_SUCCESS, "_pCaptureStartTimer start fail[%s]", GetErrorMessage(r));
}
}
break;
bool isCharging = false;
BatteryLevel batteryLevel;
- batteryLevel = __pCameraPresentationModel->GetBatteryLevel();
- isCharging = __pCameraPresentationModel->IsCharging();
+ batteryLevel = _pCameraPresentationModel->GetBatteryLevel();
+ isCharging = _pCameraPresentationModel->IsCharging();
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
bool value = false;
int cameraCount = 0;
- if (__pCameraPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW)
+ if (_pCameraPresentationModel->GetCameraState() != CAMERA_STATE_PREVIEW)
{
AppLogDebug("Camera Preview is not");
return;
}
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_COUNT, cameraCount);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_COUNT, cameraCount);
AppLogDebug("GetMediaCapability [%s]", GetErrorMessage(r));
if (cameraCount < SUPPORTED_CAMERA_NUM)
return;
}
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to get value to registry[%s]", GetErrorMessage(r));
MakeSettingPopupTab(false);
__isToggleCameraDirection = true;
+ r = _pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY);
+ TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
+
r = ToggleCameraDirection(CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY);
TryReturnVoid(r == E_SUCCESS, "ToggleCameraDirection() fail[%s]", GetErrorMessage(r));
- r = __pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY);
- TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
- r = __pCameraPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
-
}
else if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
{
int primaryFlashValue = FLASH_MODE_OFF;
__isToggleCameraDirection = true;
+ r = _pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
+ TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
+
r = ToggleCameraDirection(CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
TryReturnVoid(r == E_SUCCESS, "ToggleCameraDirection() fail[%s]", GetErrorMessage(r));
- r = __pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
- TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
-
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
- __pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, primaryFlashValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ _pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, primaryFlashValue);
if (value == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, primaryFlashValue);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, primaryFlashValue);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
}
}
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
UpdateUiPanelIcon();
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
HideUiQuickMenu();
}
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
MakeCameraTabSettingPopup();
}
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
if (__pListViewGeneralTabMainMenu)
{
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
AppLogDebug("IDA_BUTTON_SETTING_GENERAL");
return;
}
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
AppLogDebug("CAMERA_SUB_MENU_CONTENT_EXPOSURE_MODE");
- r = __pCameraPresentationModel->GetValue(EXPOSURE_VALUE, adjustValue);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, adjustValue);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
AppLogDebug("adjustValue = %d", adjustValue);
- __pCameraPresentationModel->SetExposure(adjustValue);
+ _pCameraPresentationModel->SetExposure(adjustValue);
MakeSettingPopupTab(false);
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
AppLogDebug("CAMERA_SUB_MENU_CONTENT_EXPOSURE_MODE");
- r = __pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, adjustValue);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, adjustValue);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
AppLogDebug("adjustValue = %d", adjustValue);
- __pCameraPresentationModel->SetBrightness(adjustValue);
+ _pCameraPresentationModel->SetBrightness(adjustValue);
MakeSettingPopupTab(false);
result r = E_SUCCESS;
int selfPortraitEnable = 0;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
if (__pCameraInfoPanel->GetDrawExposure() == true)
{
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
__pCameraInfoPanel->SetDrawExposure(false);
Invalidate(true);
}
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
}
if (r == E_SUCCESS)
__pResetPopUp->SetShowState(false);
}
- r = __pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
TryReturnVoid(r == E_SUCCESS, "GetValue() fail(%s)", GetErrorMessage(r));
if (guideLineEnable == CAMERA_GUIDELINE_ENABLE)
SetGuideLine(SUBMENU_MODE_OFF);
}
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "GetValue() fail(%s)", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
AppLogDebug("SUBMENU_RESET_MODE : CAMERA_FORM_SECONDARY_MODE");
- r = __pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
+ r = _pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
TryReturnVoid(r == E_SUCCESS, "SetValue() fail(%s)", GetErrorMessage(r));
r = ToggleCameraDirection(CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "GetBackgroundBufferInfo() fail(%s)", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
MakePreviewResolutionList(true);
RestoreDefaultSetting();
}
- r = __pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ r = _pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
TryReturnVoid(r == E_SUCCESS, "Reg setValue fail[%s]", GetErrorMessage(r));
MakeSettingPopupTab(false);
AppLogDebug("EXIT");
}
-result
-CameraForm::SendAppControlResult(RequestId requestId)
-{
- AppLogDebug("ENTER");
- result r = E_SUCCESS;
- String fullFileName = L"";
- int storageType = STORAGE_TYPE_PHONE;
- int mode = CameraPresentationModel::CAMERA_MODE_SNAPSHOT;
- String filePath = L"";
- int requestType = 0;
-
- HashMap* pExtraData = new (std::nothrow) HashMap(SingleObjectDeleter);
- r = pExtraData->Construct();
- AppLogDebug("HashMap::Construct() fail[%s]", GetErrorMessage(r));
-
- if (GetAppLaunchType() == APP_LAUNCH_TYPE_REQUESET)
- {
- requestType = __pCameraPresentationModel->GetAppControlRequestType();
-
- switch (requestType)
- {
- case CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_CANCELED:
- {
- r = ReturnValues(requestId, APP_CTRL_RESULT_CANCELED, null);
- TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
- }
- break;
-
- case CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_SUCCEEDED:
- {
- r = __pCameraPresentationModel->GetValue(CURRENT_MODE, mode);
- TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
-
- r = __pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
- TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
-
- if (storageType == STORAGE_TYPE_PHONE)
- {
- r = filePath.Format(MAX_DIRECTORY_PATH_LENGTH, L"%ls%ls", Environment::GetMediaPath().GetPointer(), STRING_CAMERA_FOLDER);
- TryCatch(r == E_SUCCESS, , "String::Format() fail[%s]", GetErrorMessage(r));
- }
- else
- {
- r = filePath.Format(MAX_DIRECTORY_PATH_LENGTH, L"%ls%ls", Environment::GetExternalStoragePath().GetPointer(), STRING_CAMERA_FOLDER);
- TryCatch(r == E_SUCCESS, , "String::Format() fail[%s]", GetErrorMessage(r));
- }
- AppLogDebug("FilePath %ls", filePath.GetPointer());
-
- if (mode == CameraPresentationModel::CAMERA_MODE_SNAPSHOT)
- {
- r = __pCameraPresentationModel->GetLatestContentName(CameraPresentationModel::CAMERA_MODE_SNAPSHOT, fullFileName);
- TryCatch(r == E_SUCCESS, , "pCameraPresentationModel->GetLatestContentName fail[%s]", GetErrorMessage(r));
- }
- else
- {
- r = __pCameraPresentationModel->GetLatestContentName(CameraPresentationModel::CAMERA_MODE_RECORD, fullFileName);
- TryCatch(r == E_SUCCESS, , "pCameraPresentationModel->GetLatestContentName fail[%s]", GetErrorMessage(r));
- }
- AppLogDebug("fullFileName:%ls", fullFileName.GetPointer());
-
- ArrayList* pPaths = new (std::nothrow) ArrayList();
- pPaths->Construct();
- pPaths->Add(new (std::nothrow) String(filePath + fullFileName));
-
- pExtraData->Add(new (std::nothrow) String(OUTPUT_KEY_RESULT), pPaths);
-
- r = ReturnValues(requestId, APP_CTRL_RESULT_SUCCEEDED, pExtraData);
- TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
- }
- break;
-
- case CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED:
- {
- r = ReturnValues(requestId, APP_CTRL_RESULT_FAILED, null);
- TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
- }
- break;
-
- default:
- break;
- }
- }
- else
- {
- AppLogDebug("Not AppControl");
- r = ReturnValues(requestId, APP_CTRL_RESULT_FAILED, null);
- TryCatch(r == E_SUCCESS, , "ReturnValues fail[%s]", GetErrorMessage(r));
- }
-
- delete pExtraData;
- pExtraData = null;
-
- AppLogDebug("EXIT");
- return r;
-
-CATCH:
- delete pExtraData;
- pExtraData = null;
-
- AppLogDebug("EXIT - CATCH");
- return r;
-}
-
-result
-CameraForm::TerminateApp(void)
-{
- AppLogDebug("ENTER");
- result r = E_SUCCESS;
- CameraApp* pCameraApp = static_cast<CameraApp*>(CameraApp::GetInstance());
-
- RemoveAllEventListener();
-
- __appControlActionCompleted = true;
-
- DeleteTimer();
-
- __chargingCount = 0;
-
- __blinkCount = 0;
-
- __timeCount = 0;
-
- __isUsedTimerCaptured = false;
-
- __closeTimerValue = 0;
-
- __closeTimerValue = 0;
-
- __pCameraPresentationModel->StopCamera();
-
- r = SendAppControlResult(pCameraApp->GetRequestId());
- TryCatch(r == E_SUCCESS, , "SendAppControlResult fail[%s]", GetErrorMessage(r));
-
- AppLogDebug("EXIT");
- return r;
-
-CATCH:
- AppLogDebug("EXIT - CATCH");
- return r;
-}
-
void
CameraForm::OnFormBackRequested(Tizen::Ui::Controls::Form& source)
{
DeleteTimer();
- __chargingCount = 0;
+ _chargingCount = 0;
- __blinkCount = 0;
+ _blinkCount = 0;
- __timeCount = 0;
+ _timeCount = 0;
- __isUsedTimerCaptured = false;
+ _isUsedTimerCaptured = false;
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- __pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
r = SendAppControlResult(pCameraApp->GetRequestId());
TryReturnVoid(r == E_SUCCESS, "SendAppControlResult [%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
}
-result
-CameraForm::LaunchAppControl(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::String* pUriData, const Tizen::Base::String* pDataType, const Tizen::Base::Collection::IMap* extraData)
-{
- AppLogDebug("ENTER");
- result r = E_SUCCESS;
- CameraApp* pCameraApp = null;
- AppControl* pAc = null;
-
- AppLogDebug("pUriData %ls", pUriData->GetPointer());
- AppLogDebug("pDataType %ls", pDataType->GetPointer());
-
-#if true
- pAc = AppManager::FindAppControlN(providerId, operationId);
- TryCatch(pAc != null, r = E_OBJ_NOT_FOUND, "Failed to find the appcontrol");
-
- r = pAc->Start(null, pDataType, extraData, null);
- TryCatch(r == E_SUCCESS, , "[%s] Failed to start the appcontrol", GetErrorMessage(r));
-
- pCameraApp = static_cast<CameraApp*>(CameraApp::GetInstance());
- pCameraApp->SetFrameEnabled(false);
- Invalidate(true);
-
- delete pAc;
-#else
- r = AppControl::FindAndStart(operationId, null, pDataType, null, extraData, null);
- TryCatch(r == E_SUCCESS, , "[%s] Failed to start the appcontrol", GetErrorMessage(r));
-#endif
- AppLogDebug("EXIT");
- return r;
-
-CATCH:
- if (pAc != null)
- {
- delete pAc;
- }
- return E_FAILURE;
-}
-
-void
-CameraForm::OnAppControlCompleted(const Tizen::Base::String& providerId, const Tizen::Base::String& operationId, const Tizen::Base::Collection::IList* pResultList)
-{
- AppLogDebug("ENTER");
- AppLogDebug("EXIT");
-}
-
void
CameraForm::OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs)
{
AppLogDebug("ENTER");
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("EXIT - App Terminate");
return;
Bitmap* pBitmap = null;
Point ptThumbnailImg = Point(X_THUMBNAIL_BUTTON_IMG, Y_THUMBNAIL_BUTTON_IMG);
- isExistThumbnail = __pCameraPresentationModel->IsExistThumbnail(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ isExistThumbnail = _pCameraPresentationModel->IsExistThumbnail(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
if (isExistThumbnail == false)
{
Construct(L"IDL_CAMERA_FORM");
- __pCameraPresentationModel = CameraPresentationModel::GetInstance();
- TryCatch(__pCameraPresentationModel != null, r = E_SYSTEM, "__pCameraPresentationModel is null");
+ _pCameraPresentationModel = CameraPresentationModel::GetInstance();
+ TryCatch(_pCameraPresentationModel != null, r = E_SYSTEM, "_pCameraPresentationModel is null");
AppLogDebug("EXIT");
return E_SUCCESS;
CameraForm::InitAppTimer(void)
{
AppLogDebug("ENTER");
- __pAppTimer = new (std::nothrow) Timer();
- __pAppTimer->Construct(*this);
+ _pAppTimer = new (std::nothrow) Timer();
+ _pAppTimer->Construct(*this);
AppLogDebug("EXIT");
}
CameraForm::InitChargingTimer(void)
{
AppLogDebug("ENTER");
- __pChargingTimer = new (std::nothrow) Timer();
- __pChargingTimer->Construct(*this);
+ _pChargingTimer = new (std::nothrow) Timer();
+ _pChargingTimer->Construct(*this);
AppLogDebug("EXIT");
}
CameraForm::InitChargingCompletedTimer(void)
{
AppLogDebug("ENTER");
- __pChargingCompletedTimer = new (std::nothrow) Timer();
- __pChargingCompletedTimer->Construct(*this);
+ _pChargingCompletedTimer = new (std::nothrow) Timer();
+ _pChargingCompletedTimer->Construct(*this);
AppLogDebug("EXIT");
}
CameraForm::InitPreviewFailPopupTimer(void)
{
AppLogDebug("ENTER");
- __pPreviewFailPopupTimer = new (std::nothrow) Timer();
- __pPreviewFailPopupTimer->Construct(*this);
+ _pPreviewFailPopupTimer = new (std::nothrow) Timer();
+ _pPreviewFailPopupTimer->Construct(*this);
AppLogDebug("EXIT");
}
CameraForm::InitIntervalValueTimer(void)
{
AppLogDebug("ENTER");
- __pIntervalValueTimer = new (std::nothrow) Timer();
- __pIntervalValueTimer->Construct(*this);
+ _pIntervalValueTimer = new (std::nothrow) Timer();
+ _pIntervalValueTimer->Construct(*this);
AppLogDebug("EXIT");
}
CameraForm::InitCaptureStartTimer(void)
{
AppLogDebug("ENTER");
- __pCaptureStartTimer = new (std::nothrow) Timer();
- __pCaptureStartTimer->Construct(*this);
+ _pCaptureStartTimer = new (std::nothrow) Timer();
+ _pCaptureStartTimer->Construct(*this);
AppLogDebug("EXIT");
}
CameraForm::InitTouchAutoFocusStartTimer(void)
{
AppLogDebug("ENTER");
- __pTouchAutoFocusTimer = new (std::nothrow) Timer();
- __pTouchAutoFocusTimer->Construct(*this);
+ _pTouchAutoFocusTimer = new (std::nothrow) Timer();
+ _pTouchAutoFocusTimer->Construct(*this);
AppLogDebug("EXIT");
}
AppLogDebug("ENTER");
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
- __pAppTimer->Cancel();
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
TryReturnVoid(r == E_SUCCESS, "Timer::Start() fail[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
}
AppLogDebug("ENTER");
result r = E_SUCCESS;
- TryReturnVoid(__pPreviewFailPopupTimer != null, "__pPreviewFailPopupTimer is null");
+ TryReturnVoid(_pPreviewFailPopupTimer != null, "__pPreviewFailPopupTimer is null");
- __pPreviewFailPopupTimer->Cancel();
+ _pPreviewFailPopupTimer->Cancel();
- r = __pPreviewFailPopupTimer->Start(PREVIEW_FAIL_TIMER);
+ r = _pPreviewFailPopupTimer->Start(PREVIEW_FAIL_TIMER);
TryReturnVoid(r == E_SUCCESS, "__pPreviewFailPopupTimer::Start() fail[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
}
result r = E_SUCCESS;
bool isCharging = false;
- TryReturnVoid(__pChargingCompletedTimer != null, "__pChargingCompletedTimer is null");
+ TryReturnVoid(_pChargingCompletedTimer != null, "__pChargingCompletedTimer is null");
- isCharging = __pCameraPresentationModel->IsCharging();
+ isCharging = _pCameraPresentationModel->IsCharging();
__batteryStatus = GetCurrentBatteryState();
AppLogDebug("__batteryStatus = %d" , __batteryStatus);
if (isCharging && __batteryStatus == BATTERY_STATE_20)
{
- if (__pChargingCompletedTimer)
+ if (_pChargingCompletedTimer)
{
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
}
- __chargingCount = 0;
+ _chargingCount = 0;
- __blinkCount = 0;
+ _blinkCount = 0;
r = DrawBatteryLevelFull();
- TryReturnVoid(r == E_SUCCESS, "__pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
+ TryReturnVoid(r == E_SUCCESS, "_pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
return;
}
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
if (__batteryStatus == BATTERY_STATE_20)
{
- if (__pChargingCompletedTimer)
+ if (_pChargingCompletedTimer)
{
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
- r = __pChargingCompletedTimer->StartAsRepeatable(CAMERA_CHARGING_TIMER);
- TryReturnVoid(r == E_SUCCESS, "__pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
+ r = _pChargingCompletedTimer->StartAsRepeatable(CAMERA_CHARGING_TIMER);
+ TryReturnVoid(r == E_SUCCESS, "_pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
}
}
else
{
- if (__pChargingCompletedTimer)
+ if (_pChargingCompletedTimer)
{
- __pChargingCompletedTimer->Cancel();
+ _pChargingCompletedTimer->Cancel();
}
- __chargingCount = 0;
- __blinkCount = 0;
+ _chargingCount = 0;
+ _blinkCount = 0;
CheckBatteryStatus();
}
result r = E_SUCCESS;
bool isCharging = false;
- TryReturnVoid(__pChargingTimer != null, "__pChargingTimer is null");
+ TryReturnVoid(_pChargingTimer != null, "_pChargingTimer is null");
- isCharging = __pCameraPresentationModel->IsCharging();
+ isCharging = _pCameraPresentationModel->IsCharging();
- __chargingCount = INDEX_UNIT_ZERO;
+ _chargingCount = INDEX_UNIT_ZERO;
if (isCharging)
{
- if (__pChargingTimer)
+ if (_pChargingTimer)
{
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
- r = __pChargingTimer->StartAsRepeatable(CAMERA_CHARGING_TIMER);
- TryReturnVoid(r == E_SUCCESS, "__pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
+ r = _pChargingTimer->StartAsRepeatable(CAMERA_CHARGING_TIMER);
+ TryReturnVoid(r == E_SUCCESS, "_pChargingTimer::Start() fail[%s]", GetErrorMessage(r));
}
}
else
{
- if (__pChargingTimer)
+ if (_pChargingTimer)
{
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
}
}
AppLogDebug("EXIT");
BufferInfo bufferinfo;
bool isInitCameraStaus = false;
- if (__pAppTimer != null)
+ if (_pAppTimer != null)
{
- __pAppTimer->Cancel();
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
}
if (direction == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
{
AppLogDebug("FRONT");
- r = __pCameraPresentationModel->ToggleCameraDirection(CameraPresentationModel::CAMERA_MODE_SNAPSHOT, CameraPresentationModel::CAMERA_DIRECTION_FRONT);
+ r = _pCameraPresentationModel->ToggleCameraDirection(CameraPresentationModel::CAMERA_MODE_SNAPSHOT, CameraPresentationModel::CAMERA_DIRECTION_FRONT);
}
else if (direction == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
AppLogDebug("BACK");
- r = __pCameraPresentationModel->ToggleCameraDirection(CameraPresentationModel::CAMERA_MODE_SNAPSHOT, CameraPresentationModel::CAMERA_DIRECTION_BACK);
+ r = _pCameraPresentationModel->ToggleCameraDirection(CameraPresentationModel::CAMERA_MODE_SNAPSHOT, CameraPresentationModel::CAMERA_DIRECTION_BACK);
}
TryCatch(r == E_SUCCESS, , "__pCamcorderPresentationModel->ToggleCameraDirection() fail[%s]", GetErrorMessage(r));
- dim = __pCameraPresentationModel->GetPreviewResolution();
+ dim = _pCameraPresentationModel->GetPreviewResolution();
AppLogDebug("CameraForm::GetPreviewResolution(W:%d, H:%d)", dim.width, dim.height);
AppLogDebug("__screenMode [%d]", __screenMode);
InDrawFocus();
- isInitCameraStaus = __pCameraPresentationModel->GetInitCameraStatus();
+ isInitCameraStaus = _pCameraPresentationModel->GetInitCameraStatus();
AppLogDebug("isInitCameraStaus [%d]", isInitCameraStaus);
if (isInitCameraStaus)
r = __pPreviewResolutionList->Construct();
TryCatch(r == E_SUCCESS, , "__pPreviewResolutionList construct fail[%s]", GetErrorMessage(r));
- pTempList = __pCameraPresentationModel->GetPreviewResolutionList();
+ pTempList = _pCameraPresentationModel->GetPreviewResolutionList();
TryCatch(pTempList != null, , "GetPreviewResolutionList() return null");
tot = pTempList->GetCount();
if (tot > 0)
r = __pCaptureResolutionList->Construct();
TryCatch(r == E_SUCCESS, , "__pCaptureResolutionList construct fail[%s]", GetErrorMessage(r));
- pTempList = __pCameraPresentationModel->GetCaptureResolutionList();
+ pTempList = _pCameraPresentationModel->GetCaptureResolutionList();
TryCatch(pTempList != null, , "GetCaptureResolutionList() return null");
tot = pTempList->GetCount();
if (tot > 0)
r = __pIsoList->Construct();
TryCatch(r == E_SUCCESS, , "__pIsoList construct fail[%s]", GetErrorMessage(r));
- pTempList = __pCameraPresentationModel->GetIsoList();
+ pTempList = _pCameraPresentationModel->GetIsoList();
TryCatch(pTempList != null, , "GetIsoList() return null");
tot = pTempList->GetCount();
if (tot > 0)
return 0;
}
-void
-CameraForm::OnKeyPressed(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode)
-{
- AppLogDebug("ENTER OnKeyPressed Control : %ls, KeyCode : %d", source.GetName().GetPointer(), keyCode);
- AppLogDebug("EXIT");
-}
-
-void
-CameraForm::OnKeyReleased(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode)
-{
- AppLogDebug("ENTER OnKeyReleased Control : %ls, KeyCode : %d", source.GetName().GetPointer(), keyCode);
- AppLogDebug("EXIT");
-}
-
-void
-CameraForm::OnKeyLongPressed(const Tizen::Ui::Control& source, Tizen::Ui::KeyCode keyCode)
-{
- AppLogDebug("ENTER OnKeyLongPressed Control : %ls, KeyCode : %d", source.GetName().GetPointer(), keyCode);
- AppLogDebug("EXIT");
-}
-
-void
-CameraForm::OnAdjustmentValueChanged(const Tizen::Ui::Control& source, int adjustment)
-{
- AppLogDebug("ENTER");
- AppLogDebug("EXIT");
-}
-
-void
-CameraForm::OnSliderBarMoved(Tizen::Ui::Controls::Slider& source, int value)
-{
- AppLogDebug("ENTER");
- AppLogDebug("EXIT");
-}
-
inline int
CameraForm::GetGeneralTabSettingMainMenuCount(void) const
{
result r = E_SUCCESS;
int timerInterval = 0;
- r = __pCameraPresentationModel->GetValue(TIMER_INTERVAL, timerInterval);
+ r = _pCameraPresentationModel->GetValue(TIMER_INTERVAL, timerInterval);
TryCatch(r == E_SUCCESS, , "Faled to get value to registry");
AppLogDebug("EXIT");
AppLogDebug("ENTER");
result r = E_SUCCESS;
- r = __pCameraPresentationModel->SetValue(GUIDELINE_ENABLE, guideLineEnable);
+ r = _pCameraPresentationModel->SetValue(GUIDELINE_ENABLE, guideLineEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
}
-void
-CameraForm::SetStorageType(int storageType)
-{
- AppLogDebug("ENTER");
- result r = E_SUCCESS;
-
- if (storageType == STORAGE_TYPE_PHONE)
- {
- r = __pCameraPresentationModel->SetValue(STORAGE_TYPE, storageType);
- TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
- }
- else if (storageType == STORAGE_TYPE_MEMORYCARD)
- {
- if (__pCameraPresentationModel->IsStorageCardMounted() == true)
- {
- AppLogDebug("StorageCard mount");
- r = __pCameraPresentationModel->SetValue(STORAGE_TYPE, storageType);
- TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_MOUNT);
- }
- else
- {
- AppLogDebug("StorageCard unmount");
- __pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
- }
- }
- AppLogDebug("EXIT");
-}
-
result
CameraForm::RestoreDefaultSetting(void)
{
bool brighnesstValue = false;
int adjustValue = 0;
- r = __pCameraPresentationModel->ResetCameraSettingsRegistry();
+ r = _pCameraPresentationModel->ResetCameraSettingsRegistry();
TryCatch(r == E_SUCCESS, ,"ResetCameraSettingsRegistry() fail[%s]", GetErrorMessage(r));
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(EXPOSURE_VALUE, adjustValue);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, adjustValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("adjustValue = %d", adjustValue);
- __pCameraPresentationModel->SetExposure(adjustValue);
+ _pCameraPresentationModel->SetExposure(adjustValue);
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, adjustValue);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, adjustValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("adjustValue = %d", adjustValue);
- __pCameraPresentationModel->SetBrightness(adjustValue);
+ _pCameraPresentationModel->SetBrightness(adjustValue);
}
}
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
}
if (r == E_SUCCESS)
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, adjustValue);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, adjustValue);
}
else
{
- r = __pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, adjustValue);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, adjustValue);
}
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("adjustValue = %d", adjustValue);
- __pCameraPresentationModel->SetWhiteBalance((CameraWhiteBalance)adjustValue);
+ _pCameraPresentationModel->SetWhiteBalance((CameraWhiteBalance)adjustValue);
}
AppLogDebug("EXIT");
Dimension captureResolutionDim;
BufferInfo bufferinfo;
- TryCatch(__pAppTimer != null, , "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryCatch(_pAppTimer != null, , "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
- pCaptureResolutionList = __pCameraPresentationModel->GetCaptureResolutionList();
+ pCaptureResolutionList = _pCameraPresentationModel->GetCaptureResolutionList();
resolutionIndex = pCaptureResolutionList->GetCount() - INDEX_UNIT_ONE;
SetOverlayRendererRotation();
}
- __pCameraPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
- __pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
- r = __pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ r = _pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
TryCatch(r == E_SUCCESS, , "SetMode fail[%s]", GetErrorMessage(r));
- pList = __pCameraPresentationModel->GetCaptureResolutionList();
+ pList = _pCameraPresentationModel->GetCaptureResolutionList();
resolutionCnt = pList->GetCount();
__captureResolutionHeight = captureResolutionDim.height;
- __pCameraPresentationModel->SetCaptureResolution(captureResolutionDim);
+ _pCameraPresentationModel->SetCaptureResolution(captureResolutionDim);
__primaryCurrentResolutionIndex = INDEX_UNIT_ZERO;
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryCatch(r == E_SUCCESS, , "GetBackgroundBufferInfo start fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
if (wideMode == true)
{
Dimension resolutionDim;
Dimension captureResolutionDim;
- TryCatch(__pAppTimer != null, , "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryCatch(_pAppTimer != null, , "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
- pCaptureResolutionList = __pCameraPresentationModel->GetCaptureResolutionList();
+ pCaptureResolutionList = _pCameraPresentationModel->GetCaptureResolutionList();
resolutionIndex = pCaptureResolutionList->GetCount() - INDEX_UNIT_ONE;
wideMode = false;
}
- pList = __pCameraPresentationModel->GetCaptureResolutionList();
+ pList = _pCameraPresentationModel->GetCaptureResolutionList();
resolutionCnt = pList->GetCount();
__captureResolutionHeight = captureResolutionDim.height;
- __pCameraPresentationModel->SetCaptureResolution(captureResolutionDim);
+ _pCameraPresentationModel->SetCaptureResolution(captureResolutionDim);
__primaryCurrentResolutionIndex = INDEX_UNIT_ZERO;
Rectangle rect = Rectangle(X_PREVIEW_OVERLAY_LANDSCAPE, Y_PREVIEW_OVERLAY_LANDSCAPE,
W_PREVIEW_OVERLAY_LANDSCAPE, H_PREVIEW_OVERLAY_LANDSCAPE);
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (__dir == ORIENTATION_STATUS_PORTRAIT
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
}
if (focusSupport == true && r == E_SUCCESS)
ResourceId resIdNormal = RESOURCE_ID_CAMERA_MODE_FLASH_AUTO_NOR;
ResourceId resIdPress = RESOURCE_ID_CAMERA_MODE_FLASH_AUTO_NOR;
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue Reg Fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
}
}
- __pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, regVal);
+ _pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, regVal);
TryCatch(__pSettingPanel != null, r = E_SYSTEM, "__pSettingPanel is null");
SetCameraTabSettingMainMenuCount(MENU_COUNT_CLEAR);
SetCameraTabSubMenuListviewState(MENU_COUNT_CLEAR, CAMERA_TAB_SUB_MENU_CONTENT_MAX);
- __pCameraPresentationModel->SetFlashMode(cameraFlashMode);
+ _pCameraPresentationModel->SetFlashMode(cameraFlashMode);
AppLogDebug("EXIT");
return E_SUCCESS;
}
}
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "Reg GetValue() fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
}
if (r == E_SUCCESS)
}
else
{
- r = __pCameraPresentationModel->SetValue(ISO_VALUE, REG_DEFAULT_VAULE_ZERO);
+ r = _pCameraPresentationModel->SetValue(ISO_VALUE, REG_DEFAULT_VAULE_ZERO);
TryCatch(r == E_SUCCESS, , "Reg SetValue() fail[%s]", GetErrorMessage(r));
drawPopup = false;
int selfPortraitEnable = 0;
CameraTabSubMenuContent idx = CAMERA_TAB_SUB_MENU_CONTENT_MAX;
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "Reg GetValue() fail[%s]", GetErrorMessage(r));
idx = GetCameraTabSettingSubMenuMode();
{
result r = E_SUCCESS;
- r = __pCameraPresentationModel->SetValue(OVERLAY_HELP_ENABLE, SCREEN_OVERLAY_HELP_ENABLE);
+ r = _pCameraPresentationModel->SetValue(OVERLAY_HELP_ENABLE, SCREEN_OVERLAY_HELP_ENABLE);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
r = SetScreenOverlayHelpTimer();
int selfPortraitEnable = 0;
GeneralTabSubMenuContent idx = GENERAL_TAB_SUB_MENU_CONTENT_MAX;
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "Reg GetValue() fail[%s]", GetErrorMessage(r));
idx = GetGeneralTabSettingSubMenuMode();
result r = E_SUCCESS;
int timerInterval = 0;
- __timeCount = 0;
+ _timeCount = 0;
- __pPopupTimer = new (std::nothrow) Timer();
+ _pPopupTimer = new (std::nothrow) Timer();
- __pPopupTimer->Construct(*this);
+ _pPopupTimer->Construct(*this);
- r = __pPopupTimer->StartAsRepeatable(CAMERA_TIMER_1_SEC);
- TryCatch(r == E_SUCCESS, , "__pPopupTimer start fail[%s]", GetErrorMessage(r));
+ r = _pPopupTimer->StartAsRepeatable(CAMERA_TIMER_1_SEC);
+ TryCatch(r == E_SUCCESS, , "_pPopupTimer start fail[%s]", GetErrorMessage(r));
timerInterval = GetTimerIntervalValue();
{
case SETTING_TIMER_CAPTURE_2_SEC:
{
- __timeCount = SETTING_TIMER_2_SEC_COUNT;
+ _timeCount = SETTING_TIMER_2_SEC_COUNT;
}
break;
case SETTING_TIMER_CAPTURE_5_SEC:
{
- __timeCount = SETTING_TIMER_5_SEC_COUNT;
+ _timeCount = SETTING_TIMER_5_SEC_COUNT;
}
break;
case SETTING_TIMER_CAPTURE_10_SEC:
{
- __timeCount = SETTING_TIMER_10_SEC_COUNT;
+ _timeCount = SETTING_TIMER_10_SEC_COUNT;
}
break;
}
__pCameraInfoPanel->SetDrawPopupTimerUpdate(true);
- __pCameraInfoPanel->SetDrawPopupTimerCount(__timeCount);
+ __pCameraInfoPanel->SetDrawPopupTimerCount(_timeCount);
__pCameraInfoPanel->Invalidate(true);
AppLogDebug("EXIT");
return E_SUCCESS;
CATCH:
- delete __pPopupTimer;
- __pPopupTimer = null;
+ delete _pPopupTimer;
+ _pPopupTimer = null;
return r;
}
{
AppLogDebug("ENTER");
result r = E_SUCCESS;
- TryCatch(__pPopupTimer != null, r = E_SYSTEM, "__pPopupTimer is null");
+ TryCatch(_pPopupTimer != null, r = E_SYSTEM, "_pPopupTimer is null");
- r = __pPopupTimer->Cancel();
+ r = _pPopupTimer->Cancel();
- delete __pPopupTimer;
- __pPopupTimer = null;
+ delete _pPopupTimer;
+ _pPopupTimer = null;
AppLogDebug("EXIT");
return E_SUCCESS;
bool exposureValue = false;
bool brighnesstValue = false;
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to Get value to registry[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(EXPOSURE_VALUE, exposure);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, exposure);
TryReturnVoid(r == E_SUCCESS, "exposure Faled to Get value to registry[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetExposure(exposure);
+ _pCameraPresentationModel->SetExposure(exposure);
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, brightness);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, brightness);
TryReturnVoid(r == E_SUCCESS, "brightness Faled to Get value to registry[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetBrightness(brightness);
+ _pCameraPresentationModel->SetBrightness(brightness);
}
}
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
}
if (r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(ISO_VALUE, isoIndex);
+ r = _pCameraPresentationModel->GetValue(ISO_VALUE, isoIndex);
TryReturnVoid(r == E_SUCCESS, "isoIndex Faled to Get value to registry[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetIsoLevel((CameraIsoLevel)isoIndex);
+ _pCameraPresentationModel->SetIsoLevel((CameraIsoLevel)isoIndex);
}
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
}
if (r == E_SUCCESS)
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, wbIndex);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, wbIndex);
}
else
{
- r = __pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, wbIndex);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, wbIndex);
}
TryReturnVoid(r == E_SUCCESS, "WB Faled to Get value to registry[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetWhiteBalance((CameraWhiteBalance)wbIndex);
+ _pCameraPresentationModel->SetWhiteBalance((CameraWhiteBalance)wbIndex);
}
AppLogDebug("EXIT");
}
pSrcByteBuff = null;
}
- if (pBitmap != null) //Prevent issue fix.\r
- {\r
- delete pBitmap;\r
- }\r
+ if (pBitmap != null) //Prevent issue fix.
+ {
+ delete pBitmap;
+ }
return null;
}
}
}
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (entryName.Equals(String(EXPOSURE_VALUE)))
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(EXPOSURE_VALUE, currentEntryValue);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, currentEntryValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, currentEntryValue);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, currentEntryValue);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
}
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->SetValue(EXPOSURE_VALUE, adjustEntryValue);
+ r = _pCameraPresentationModel->SetValue(EXPOSURE_VALUE, adjustEntryValue);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->SetValue(BRIGHTNESS_VALUE, adjustEntryValue);
+ r = _pCameraPresentationModel->SetValue(BRIGHTNESS_VALUE, adjustEntryValue);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
}
}
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- __pCameraPresentationModel->SetExposure(adjustEntryValue);
+ _pCameraPresentationModel->SetExposure(adjustEntryValue);
}
else
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- __pCameraPresentationModel->SetBrightness(adjustEntryValue);
+ _pCameraPresentationModel->SetBrightness(adjustEntryValue);
}
else
{
TryCatch(__pCameraInfoPanel != null, r = E_FAILURE, "__pCameraInfoPanel is null");
- __closeTimerValue = 0;
- __pExposureCloseTimer = new (std::nothrow) Timer();
- __pExposureCloseTimer->Construct(*this);
+ _closeTimerValue = 0;
+ _pExposureCloseTimer = new (std::nothrow) Timer();
+ _pExposureCloseTimer->Construct(*this);
- __pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
+ _pExposureCloseTimer->StartAsRepeatable(CAMERA_EXPOSURE_TIMER_VALUE);
TryCatch(r == E_SUCCESS, , "Timer::start fail[%s]", GetErrorMessage(r));
__pCameraInfoPanel->SetDrawExposure(true);
return r;
CATCH:
- delete __pExposureCloseTimer;
- __pExposureCloseTimer = null;
+ delete _pExposureCloseTimer;
+ _pExposureCloseTimer = null;
return r;
}
bool exposureValue = false;
bool brighnesstValue = false;
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "exposure Faled to Get value to registry[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(EXPOSURE_VALUE, exposure);
+ r = _pCameraPresentationModel->GetValue(EXPOSURE_VALUE, exposure);
TryCatch(r == E_SUCCESS, , "exposure Faled to Get value to registry[%s]", GetErrorMessage(r));
AppLogDebug("Exposure value %d", exposure);
}
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
{
- r = __pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, exposure);
+ r = _pCameraPresentationModel->GetValue(BRIGHTNESS_VALUE, exposure);
TryCatch(r == E_SUCCESS, , "exposure Faled to Get value to registry[%s]", GetErrorMessage(r));
AppLogDebug("Exposure value %d", exposure);
}
bool brighnesstValue = false;
result r = E_SUCCESS;
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
- if (__pExposureCloseTimer->Cancel() == E_SUCCESS)
+ if (_pExposureCloseTimer->Cancel() == E_SUCCESS)
{
HidePopup();
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_EXPOSURE, exposureValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_EXPOSURE, exposureValue);
}
if (exposureValue == true && r == E_SUCCESS)
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_BRIGHTNESS, brighnesstValue);
}
if (brighnesstValue == true && r == E_SUCCESS)
int selfPortraitEnable = CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY;
int guideLineEnable = DISABLE_GUIDELINE;
- if (__appControlActionCompleted)
+ if (_appControlActionCompleted)
{
AppLogDebug("OnOrientationChanged >> TerminateApp Execution");
{
__isOrientationChanged = true;
- if (__pAppTimer != null)
+ if (_pAppTimer != null)
{
- __pAppTimer->Cancel();
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
}
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Read Reg fail[%s]", GetErrorMessage(r));
SetOverlayPanelOrientationChanged(orientationStatus);
__deviceOrientation = orientationStatus;
AppLogDebug("__dir = %d", __dir);
- __pCameraPresentationModel->SetOrientation(__dir);
+ _pCameraPresentationModel->SetOrientation(__dir);
- r = __pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
TryReturnVoid(r == E_SUCCESS, "Read Reg fail[%s]", GetErrorMessage(r));
if (guideLineEnable == DISABLE_GUIDELINE)
if (__isTimerRunning)
{
- if (__pHelpCloseTimer)
+ if (_pHelpCloseTimer)
{
- __pHelpCloseTimer->Cancel();
+ _pHelpCloseTimer->Cancel();
- delete __pHelpCloseTimer;
- __pHelpCloseTimer = null;
+ delete _pHelpCloseTimer;
+ _pHelpCloseTimer = null;
}
HideScreenOverlayHelp();
int selfPortraitEnable = 0;
BufferInfo bufferinfo;
- r = __pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ r = _pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
TryReturnVoid(r == E_SUCCESS, "SetMode() failed:%s", GetErrorMessage(r));
if (isWideMode == true)
{
- pList = __pCameraPresentationModel->GetPreviewResolutionList();
+ pList = _pCameraPresentationModel->GetPreviewResolutionList();
if (pList)
{
AppLogDebug("Wide Mode W[%d] x H[%d]", resolutionDim.width, resolutionDim.height);
- __pCameraPresentationModel->SetPreviewResolution(resolutionDim);
+ _pCameraPresentationModel->SetPreviewResolution(resolutionDim);
}
else
{
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Faled to set value to registry[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetPreviewResolution(normalMode);
+ _pCameraPresentationModel->SetPreviewResolution(normalMode);
__previewResolutionWidth = normalMode.width;
__previewResolutionHeight = normalMode.height;
if (__isToggleCameraDirection)
{
- pList = __pCameraPresentationModel->GetPreviewResolutionList();
+ pList = _pCameraPresentationModel->GetPreviewResolutionList();
resolutionCnt = pList->GetCount();
}
else
{
- captureResolutionDim = __pCameraPresentationModel->GetCaptureResolution();
+ captureResolutionDim = _pCameraPresentationModel->GetCaptureResolution();
__captureResolutionWidth = captureResolutionDim.width;
__captureResolutionHeight = captureResolutionDim.height;
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "GetBackgroundBufferInfo fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
previewResolutionSize = __previewResolutionWidth * __previewResolutionHeight;
{
if (__screenMode != mode)
{
- TryCatch(__pAppTimer != null, r = E_SYSTEM, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryCatch(_pAppTimer != null, r = E_SYSTEM, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
- __pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
}
else
{
if (__isToggleCameraDirection || __resolutionChange)
{
- TryCatch(__pAppTimer != null, r = E_SYSTEM, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryCatch(_pAppTimer != null, r = E_SYSTEM, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
- __pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
}
}
{
if (__screenMode != mode)
{
- TryCatch(__pAppTimer != null, r = E_SYSTEM, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryCatch(_pAppTimer != null, r = E_SYSTEM, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
- __pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
}
else
{
if (__isToggleCameraDirection || __resolutionChange)
{
- TryCatch(__pAppTimer != null, r = E_SYSTEM, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryCatch(_pAppTimer != null, r = E_SYSTEM, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryCatch(r == E_SUCCESS, , "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryCatch(r == E_SUCCESS, , "_pAppTimer start fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
- __pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->StopCamera();
}
}
return E_SUCCESS;
}
- if (__pCameraPresentationModel->GetPreviewState() == false)
+ if (_pCameraPresentationModel->GetPreviewState() == false)
{
AppLogDebug("EXIT - StartPreview do not call");
__pBackButton->SetEnabled(false);
if (__pCameraInfoPanel->GetDrawExposure() == true)
{
- __closeTimerValue = 0;
+ _closeTimerValue = 0;
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
__pCameraInfoPanel->SetDrawExposure(false);
{
AppLogDebug("PressBackButton >> Back to the App");
- if (__pCameraPresentationModel->GetCameraState()!= CAMERA_STATE_CAPTURED)
+ if (_pCameraPresentationModel->GetCameraState()!= CAMERA_STATE_CAPTURED)
{
- __pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_CANCELED);
+ _pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_CANCELED);
}
r = TerminateApp();
{
AppLogDebug("__isTimerRunning:false");
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Reg getValue fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
}
if (focusSupport == true && r == E_SUCCESS)
__pCameraInfoPanel->SetDrawMarkerFocus(false);
__pCameraInfoPanel->Invalidate(true);
}
- __pCameraPresentationModel->SetAutoFocusPoint(currentPosition);
+ _pCameraPresentationModel->SetAutoFocusPoint(currentPosition);
}
else
{
CameraForm::DoCapture(void)
{
AppLogDebug("ENTER");
- __pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __timeCount = INDEX_UNIT_ZERO;
- __pPopupTimer->Cancel();
+ _timeCount = INDEX_UNIT_ZERO;
+ _pPopupTimer->Cancel();
}
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
if (__pCameraInfoPanel->GetDrawExposure() == true)
Invalidate(true);
}
- if (__pTouchAutoFocusTimer)
+ if (_pTouchAutoFocusTimer)
{
- __pTouchAutoFocusTimer->Cancel();
+ _pTouchAutoFocusTimer->Cancel();
}
- if (__pChargingTimer)
+ if (_pChargingTimer)
{
- __pChargingTimer->Cancel();
+ _pChargingTimer->Cancel();
}
HidePopup();
int index = 0;
int loopCount = 0;
- if (__pPopupTimer)
+ if (_pPopupTimer)
{
- __timeCount = INDEX_UNIT_ZERO;
- __pPopupTimer->Cancel();
+ _timeCount = INDEX_UNIT_ZERO;
+ _pPopupTimer->Cancel();
}
- if (__pExposureCloseTimer)
+ if (_pExposureCloseTimer)
{
- __pExposureCloseTimer->Cancel();
+ _pExposureCloseTimer->Cancel();
}
HidePopup();
ArrayList* pContentPathList = new (std::nothrow) ArrayList(SingleObjectDeleter);
pContentPathList->Construct();
- pContentPathList = __pCameraPresentationModel->GetContentPathListN(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ pContentPathList = _pCameraPresentationModel->GetContentPathListN(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
if (pContentPathList == null)
{
delete pExtraData;
return;
}
- loopCount = __pCameraPresentationModel->GetContentCount();
+ loopCount = _pCameraPresentationModel->GetContentCount();
for (index = 0; index < loopCount; ++index)
{
filePath = static_cast<const String*>(pContentPathList->GetAt(index));
currentPosition.y = (rect.height / DIVIDE_BY_TWO);
}
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryReturnVoid(r == E_SUCCESS, "Read Reg fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FOCUS, focusSupport);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_SUPPORT_FOCUS, focusSupport);
}
if (focusSupport == true && r == E_SUCCESS)
__isLockScreenMode = false;
- __pCameraPresentationModel->KeepScreenOnState(true, false);
+ _pCameraPresentationModel->KeepScreenOnState(true, false);
StartInitAppTimer();
StartInitChargingTimer();
- r = __pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ r = _pCameraPresentationModel->SetMode(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
TryReturnVoid(r == E_SUCCESS, "SetMode() failed:%s", GetErrorMessage(r));
Update();
- previewResolutionDim = __pCameraPresentationModel->GetPreviewResolution();
+ previewResolutionDim = _pCameraPresentationModel->GetPreviewResolution();
AppLogDebug("CameraForm::GetPreviewResolution(W:%d, H:%d)", previewResolutionDim.width, previewResolutionDim.height);
__previewResolutionWidth = previewResolutionDim.width;
__previewResolutionHeight = previewResolutionDim.height;
- captureResolutionDim = __pCameraPresentationModel->GetCaptureResolution();
+ captureResolutionDim = _pCameraPresentationModel->GetCaptureResolution();
AppLogDebug("CameraForm::captureResolutionDim(W:%d, H:%d)", previewResolutionDim.width, previewResolutionDim.height);
AppLogDebug("__screenMode [%d]", __screenMode);
InDrawFocus();
- r = __pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ r = _pCameraPresentationModel->SetValue(CURRENT_MODE, CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
TryReturnVoid(r == E_SUCCESS, "Write Reg fail[%s]", GetErrorMessage(r));
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "GetBackgroundBufferInfo fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
previewResolutionSize = __previewResolutionWidth * __previewResolutionHeight;
if (__isTimerRunning == true)
{
StopPopupTimer();
- __timeCount = INDEX_UNIT_ZERO;
+ _timeCount = INDEX_UNIT_ZERO;
__isTimerRunning = false;
- __pCameraPresentationModel->SetIntervalTimerRun(false);
- __isUsedTimerCaptured = false;
+ _pCameraPresentationModel->SetIntervalTimerRun(false);
+ _isUsedTimerCaptured = false;
- if (__pIntervalValueTimer != null)
+ if (_pIntervalValueTimer != null)
{
- __pIntervalValueTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
__pCameraInfoPanel->SetDrawPopupTimerUpdate(false);
HideUiPanel(false);
}
- if (__pAppTimer != null)
+ if (_pAppTimer != null)
{
- __pAppTimer->Cancel();
+ _pAppTimer->Cancel();
}
- if (__pChargingTimer != null)
+ if (_pChargingTimer != null)
{
- __chargingCount = 0;
- __pChargingTimer->Cancel();
+ _chargingCount = 0;
+ _pChargingTimer->Cancel();
}
- if (__pChargingCompletedTimer != null)
+ if (_pChargingCompletedTimer != null)
{
- __chargingCount = 0;
- __blinkCount = 0;
- __pChargingCompletedTimer->Cancel();
+ _chargingCount = 0;
+ _blinkCount = 0;
+ _pChargingCompletedTimer->Cancel();
}
- if (__pPreviewFailPopupTimer != null)
+ if (_pPreviewFailPopupTimer != null)
{
- __pPreviewFailPopupTimer->Cancel();
+ _pPreviewFailPopupTimer->Cancel();
}
__pCameraInfoPanel->SetDrawMarkerFocus(false);
HidePopup();
- __pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
- __pCameraPresentationModel->StopCamera();
- __pCameraPresentationModel->KeepScreenOnState(false, true);
+ _pCameraPresentationModel->SetStorageCardChageState(CameraPresentationModel::STORAGE_CARD_CHAGE_STATE_UNKNOWN);
+ _pCameraPresentationModel->StopCamera();
+ _pCameraPresentationModel->KeepScreenOnState(false, true);
AppLogDebug("EXIT");
}
W_PREVIEW_OVERLAY_LANDSCAPE, H_PREVIEW_OVERLAY_LANDSCAPE);
}
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
r = __pOverlayPanel->GetBackgroundBufferInfo(bufferinfo);
TryReturnVoid(r == E_SUCCESS, "GetBackgroundBufferInfo fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->StartPreview(&bufferinfo);
+ _pCameraPresentationModel->StartPreview(&bufferinfo);
- __pCameraPresentationModel->SetContinuousAutoFocus();
+ _pCameraPresentationModel->SetContinuousAutoFocus();
- r = __pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, guideLineEnable);
TryReturnVoid(r == E_SUCCESS, "Read Reg fail[%s]", GetErrorMessage(r));
if (guideLineEnable == DISABLE_GUIDELINE)
StopPopupTimer();
- __isUsedTimerCaptured = false;
- AppLogDebug("EXIT");
-}
-
-void
-CameraForm::ShowCameraFailPopup(void)
-{
- AppLogDebug("ENTER");
- int modalResult = 0;
- MessageBox msgBox;
- String tmpString = L"";
- result r = E_SUCCESS;
- AppResource* pAppResource = null;
-
- pAppResource = Application::GetInstance()->GetAppResource();
- TryReturnVoid(pAppResource != null, "Failed to allocate memory for pAppResource");
-
- pAppResource->GetString(L"IDS_CAM_POP_CAMERA_FAILED", tmpString);
-
- r = msgBox.Construct(L"", tmpString, MSGBOX_STYLE_NONE, MESSAGEBOX_DISPLAY_TIME_2_SEC);
- TryReturnVoid(r == E_SUCCESS, "msgBox::Construct() failed by [%s]", GetErrorMessage(r));
- msgBox.ShowAndWait(modalResult);
-
- switch (modalResult)
- {
- case MSGBOX_RESULT_CLOSE:
- {
- __pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
-
- r = __pCameraPresentationModel->SetValue(SELF_PORTRAIT_ENABLE, CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY);
- AppLogDebug("SetValue fail [%s]", GetErrorMessage(r));
-
- r = TerminateApp();
- AppLogDebug("TerminateApp fail [%s]", GetErrorMessage(r));
- }
- break;
-
- default:
- break;
- }
- AppLogDebug("EXIT");
-}
-
-void
-CameraForm::ShowUnlaunchPopup(void)
-{
- AppLogDebug("ENTER");
- int modalResult = 0;
- MessageBox msgBox;
- String tmpString;
- AppResource* pAppResource = null;
- result r = E_SUCCESS;
-
- pAppResource = Application::GetInstance()->GetAppResource();
- TryReturnVoid(pAppResource != null, "Failed to allocate memory for pAppResource");
-
- pAppResource->GetString(L"IDS_CAM_POP_UNABLE_TO_START_CAMERA_DURING_CALL", tmpString);
-
- r = msgBox.Construct(L"", tmpString, MSGBOX_STYLE_NONE, MESSAGEBOX_DISPLAY_TIME_3_SEC);
- TryReturnVoid(r == E_SUCCESS, "msgBox::Construct() failed by [%s]", GetErrorMessage(r));
- msgBox.ShowAndWait(modalResult);
-
- __pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
- r = TerminateApp();
- AppLogDebug("TerminateApp fail [%s]", GetErrorMessage(r));
-
- AppLogDebug("EXIT");
-}
-
-void
-CameraForm::ShowLowBatteryPopup(void)
-{
- AppLogDebug("ENTER");
- int modalResult = 0;
- MessageBox msgBox;
- String tmpString;
- AppResource* pAppResource = null;
- result r = E_SUCCESS;
-
- pAppResource = Application::GetInstance()->GetAppResource();
- TryReturnVoid(pAppResource != null, "Failed to allocate memory for pAppResource");
-
- pAppResource->GetString(L"IDS_COM_BODY_LOW_BATTERY", tmpString);
-
- r = msgBox.Construct(L"", tmpString, MSGBOX_STYLE_NONE, MESSAGEBOX_DISPLAY_TIME_3_SEC);
- TryReturnVoid(r == E_SUCCESS, "msgBox::Construct() failed by [%s]", GetErrorMessage(r));
- msgBox.ShowAndWait(modalResult);
-
- switch (modalResult)
- {
- case MSGBOX_RESULT_CLOSE:
- {
- AppLogDebug("MSGBOX_RESULT_CLOSE");
-
- __pCameraPresentationModel->SetAppControlRequestType(CameraPresentationModel::APP_CONTROL_REQUEST_TYPE_FAILED);
-
- r = TerminateApp();
- AppLogDebug("TerminateApp fail [%s]", GetErrorMessage(r));
- }
- break;
-
- default:
- break;
- }
+ _isUsedTimerCaptured = false;
AppLogDebug("EXIT");
}
result r = E_SUCCESS;
int overlayHelpEnable = 0;
- r = __pCameraPresentationModel->GetValue(OVERLAY_HELP_ENABLE, overlayHelpEnable);
+ r = _pCameraPresentationModel->GetValue(OVERLAY_HELP_ENABLE, overlayHelpEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("SetScreenOverlayHelpTimer : overlayHelpEnable = %d", overlayHelpEnable);
if (overlayHelpEnable == SCREEN_OVERLAY_HELP_ENABLE)
{
- __pHelpCloseTimer = new (std::nothrow) Timer();
- __pHelpCloseTimer->Construct(*this);
+ _pHelpCloseTimer = new (std::nothrow) Timer();
+ _pHelpCloseTimer->Construct(*this);
- r = __pHelpCloseTimer->Start(CAMERA_SCREEN_OVERLAY_HELP_TIMER_VALUE);
+ r = _pHelpCloseTimer->Start(CAMERA_SCREEN_OVERLAY_HELP_TIMER_VALUE);
TryCatch(r == E_SUCCESS, , "Timer::start fail[%s]", GetErrorMessage(r));
}
return r;
CATCH:
- delete __pHelpCloseTimer;
- __pHelpCloseTimer = null;
+ delete _pHelpCloseTimer;
+ _pHelpCloseTimer = null;
AppLogDebug("EXIT - CATCH");
return r;
TryCatch(__pHelpGoToPreviousScreen != null, r = E_FAILURE, "__pHelpGoToPreviousScreen is null");
TryCatch(__pHelpGoToPreviousScreenText != null, r = E_FAILURE, "__pHelpGoToPreviousScreenText is null");
- r = __pCameraPresentationModel->GetValue(OVERLAY_HELP_ENABLE, overlayHelpEnable);
+ r = _pCameraPresentationModel->GetValue(OVERLAY_HELP_ENABLE, overlayHelpEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("DrawScreenOverlayHelp : overlayHelpEnable = %d", overlayHelpEnable);
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
if (__pListViewGeneralTabMainMenu)
{
{
result r = E_SUCCESS;
- TryReturnVoid(__pAppTimer != null, "__pAppTimer is null");
- __pAppTimer->Cancel();
+ TryReturnVoid(_pAppTimer != null, "_pAppTimer is null");
+ _pAppTimer->Cancel();
- r = __pAppTimer->Start(CAMERA_TIMER_LIMIT);
- TryReturnVoid(r == E_SUCCESS, "__pAppTimer start fail[%s]", GetErrorMessage(r));
+ r = _pAppTimer->Start(CAMERA_TIMER_LIMIT);
+ TryReturnVoid(r == E_SUCCESS, "_pAppTimer start fail[%s]", GetErrorMessage(r));
if (__pListViewCameraTabMainMenu)
{
CameraForm::CancelTimer(void)
{
AppLogDebug("ENTER");
- if (__pAppTimer != null)
- {
- __pAppTimer->Cancel();
- }
-
- if (__pIntervalValueTimer != null)
- {
- __pIntervalValueTimer->Cancel();
- }
-
- if (__pCaptureStartTimer != null)
- {
- __pCaptureStartTimer->Cancel();
- }
-
- if (__pTouchAutoFocusTimer != null)
- {
- __pTouchAutoFocusTimer->Cancel();
- }
-
- if (__pPopupTimer)
- {
- __pPopupTimer->Cancel();
- }
-
- if (__pExposureCloseTimer)
- {
- __pExposureCloseTimer->Cancel();
- }
-
- if (__pHelpCloseTimer)
- {
- __pHelpCloseTimer->Cancel();
- }
-
- if (__pChargingTimer)
- {
- __chargingCount = INDEX_UNIT_ZERO;
-
- __pChargingTimer->Cancel();
- }
-
- if (__pChargingCompletedTimer != null)
+ if (_pAppTimer != null)
{
- __chargingCount = 0;
- __blinkCount = 0;
- __pChargingCompletedTimer->Cancel();
+ _pAppTimer->Cancel();
}
- if (__pPreviewFailPopupTimer != null)
+ if (_pIntervalValueTimer != null)
{
- __pPreviewFailPopupTimer->Cancel();
+ _pIntervalValueTimer->Cancel();
}
- AppLogDebug("EXIT");
-}
-void
-CameraForm::DeleteTimer(void)
-{
- AppLogDebug("ENTER");
- if (__pAppTimer != null)
+ if (_pCaptureStartTimer != null)
{
- __pAppTimer->Cancel();
- delete __pAppTimer;
- __pAppTimer = null;
+ _pCaptureStartTimer->Cancel();
}
- if (__pIntervalValueTimer != null)
+ if (_pTouchAutoFocusTimer != null)
{
- __pIntervalValueTimer->Cancel();
- delete __pIntervalValueTimer;
- __pIntervalValueTimer = null;
+ _pTouchAutoFocusTimer->Cancel();
}
- if (__pCaptureStartTimer != null)
+ if (_pPopupTimer)
{
- __pCaptureStartTimer->Cancel();
- delete __pCaptureStartTimer;
- __pCaptureStartTimer = null;
+ _pPopupTimer->Cancel();
}
- if (__pTouchAutoFocusTimer != null)
+ if (_pExposureCloseTimer)
{
- __pTouchAutoFocusTimer->Cancel();
- delete __pTouchAutoFocusTimer;
- __pTouchAutoFocusTimer = null;
+ _pExposureCloseTimer->Cancel();
}
- if (__pPopupTimer)
+ if (_pHelpCloseTimer)
{
- __pPopupTimer->Cancel();
- delete __pPopupTimer;
- __pPopupTimer = null;
+ _pHelpCloseTimer->Cancel();
}
- if (__pExposureCloseTimer)
+ if (_pChargingTimer)
{
- __pExposureCloseTimer->Cancel();
- delete __pExposureCloseTimer;
- __pExposureCloseTimer = null;
- }
+ _chargingCount = INDEX_UNIT_ZERO;
- if (__pHelpCloseTimer)
- {
- __pHelpCloseTimer->Cancel();
- delete __pHelpCloseTimer;
- __pHelpCloseTimer = null;
+ _pChargingTimer->Cancel();
}
- if (__pChargingTimer)
+ if (_pChargingCompletedTimer != null)
{
- __pChargingTimer->Cancel();
- delete __pChargingTimer;
- __pChargingTimer = null;
+ _chargingCount = 0;
+ _blinkCount = 0;
+ _pChargingCompletedTimer->Cancel();
}
- if (__pChargingCompletedTimer)
+ if (_pPreviewFailPopupTimer != null)
{
- __pChargingCompletedTimer->Cancel();
- delete __pChargingCompletedTimer;
- __pChargingCompletedTimer = null;
- }
-
- if (__pPreviewFailPopupTimer)
- {
- __pPreviewFailPopupTimer->Cancel();
- delete __pPreviewFailPopupTimer;
- __pPreviewFailPopupTimer = null;
+ _pPreviewFailPopupTimer->Cancel();
}
AppLogDebug("EXIT");
}
__settingTimeInterval = index;
regVal = index;
- r = __pCameraPresentationModel->SetValue(TIMER_INTERVAL, regVal);
+ r = _pCameraPresentationModel->SetValue(TIMER_INTERVAL, regVal);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
__pCameraInfoPanel->SetTimerType(regVal);
int regVal = 0;
int selfPortraitEnable = 0;
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
}
if (r == E_SUCCESS)
{
- __pCameraPresentationModel->SetIsoLevel((CameraIsoLevel)index);
+ _pCameraPresentationModel->SetIsoLevel((CameraIsoLevel)index);
}
__settingIsoIndex = index;
regVal = __settingIsoIndex;
- r = __pCameraPresentationModel->SetValue(ISO_VALUE, regVal);
+ r = _pCameraPresentationModel->SetValue(ISO_VALUE, regVal);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
String strRegKey = IDS_INIT_REG_KEY;
int selfPortraitEnable = 0;
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
}
if (r == E_SUCCESS)
{
- __pCameraPresentationModel->SetWhiteBalance((CameraWhiteBalance)index);
+ _pCameraPresentationModel->SetWhiteBalance((CameraWhiteBalance)index);
}
__settingWhiteBalance = index;
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_PRIMARY, regVal);
+ r = _pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_PRIMARY, regVal);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
}
else
{
- r = __pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_SECONDARY, regVal);
+ r = _pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_SECONDARY, regVal);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
}
SetGuideLine(value);
regVal = value;
- r = __pCameraPresentationModel->SetValue(GUIDELINE_ENABLE, regVal);
+ r = _pCameraPresentationModel->SetValue(GUIDELINE_ENABLE, regVal);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("EXIT");
regVal = value;
- r = __pCameraPresentationModel->SetValue(OVERLAY_HELP_ENABLE, regVal);
+ r = _pCameraPresentationModel->SetValue(OVERLAY_HELP_ENABLE, regVal);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("Setting - OVERLAY_HELP_ENABLE = %d", OVERLAY_HELP_ENABLE);
CameraForm::SubListPopupResolutionMode(int index)
{
AppLogDebug("ENTER");
- IList* pList = __pCameraPresentationModel->GetCaptureResolutionList();
+ IList* pList = _pCameraPresentationModel->GetCaptureResolutionList();
int resolutionCnt = 0;
BufferInfo bufferinfo;
int resolutionRatio = 0;
int regVal = 0;
int selfPortraitEnable = 0;
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
if (pList)
{
}
else
{
- __pCameraPresentationModel->StopPreview();
+ _pCameraPresentationModel->StopPreview();
- __pCameraPresentationModel->SetCaptureResolution(dimCaptureResolution);
+ _pCameraPresentationModel->SetCaptureResolution(dimCaptureResolution);
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->SetValue(PRIMARY_RESOLUTION_INDEX,index);
+ r = _pCameraPresentationModel->SetValue(PRIMARY_RESOLUTION_INDEX,index);
AppLogDebug("result is %s",GetErrorMessage(r));
}
else
{
- r = __pCameraPresentationModel->SetValue(SECONDARY_RESOLUTION_INDEX,index);
+ r = _pCameraPresentationModel->SetValue(SECONDARY_RESOLUTION_INDEX,index);
}
AppLogDebug("dimCaptureResolution(W:%d, H:%d)", dimCaptureResolution.width, dimCaptureResolution.height);
AppLogDebug("Setting - Storage type = card");
storage = STORAGE_TYPE_MEMORYCARD;
- if (__pCameraPresentationModel->IsStorageCardMounted() == true)
+ if (_pCameraPresentationModel->IsStorageCardMounted() == true)
{
SetStorageType(storage);
}
break;
}
- __pCameraPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
+ _pCameraPresentationModel->UpdateThumbnail(CameraPresentationModel::CAMERA_MODE_SNAPSHOT);
Update();
AppLogDebug("FileEventManager()::Construct() fail[%s]", GetErrorMessage(r));
}
- filePath = __pCameraPresentationModel->GetfilePath(storage);
+ filePath = _pCameraPresentationModel->GetfilePath(storage);
AppLogDebug("filePath %ls", filePath.GetPointer());
elementId = (index * MENU_TWO_ELEMENT);
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
strTmp = __pSettingMenuString[index][0];
{
if (index == CAMERA_TAB_SUB_MENU_CONTENT_ISO_MODE)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
if (r == E_SUCCESS)
{
}
else if (index == CAMERA_TAB_SUB_MENU_CONTENT_CAPTURE_RESOLUTION_MODE)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_CAPTURE_RESOLUTION);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_CAPTURE_RESOLUTION);
if (r == E_SUCCESS)
{
{
if (index == CAMERA_TAB_SUB_MENU_CONTENT_ISO_MODE)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
if (r == E_SUCCESS && __pIsoList->GetCount()>1)
{
}
else if (index == CAMERA_TAB_SUB_MENU_CONTENT_CAPTURE_RESOLUTION_MODE)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_CAPTURE_RESOLUTION);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_CAPTURE_RESOLUTION);
if (r == E_SUCCESS)
{
}
}
- r = __pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
- if (storageType == STORAGE_TYPE_MEMORYCARD && __pCameraPresentationModel->IsStorageCardMounted() == false)
+ if (storageType == STORAGE_TYPE_MEMORYCARD && _pCameraPresentationModel->IsStorageCardMounted() == false)
{
- r = __pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
}
if (index == CAMERA_TAB_SUB_MENU_CONTENT_CAPTURE_RESOLUTION_MODE)
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
AppLogDebug("CAM_SELF_PORTRAIT_MODE_PRIMARY");
+ r = _pCameraPresentationModel->GetValue(PRIMARY_RESOLUTION_INDEX, __primaryCurrentResolutionIndex);
if (idx == 0)
{
if (__primaryCurrentResolutionIndex == INDEX_UNIT_ONE)
if (idx == 0)
{
AppLogDebug("CAM_SELF_PORTRAIT_MODE_SECONDARY");
+ r = _pCameraPresentationModel->GetValue(SECONDARY_RESOLUTION_INDEX, __secondaryCurrentResolutionIndex);
+
if (__secondaryCurrentResolutionIndex == INDEX_UNIT_ONE)
{
__secondaryCurrentResolutionIndex = __secondaryCurrentResolutionIndex - INDEX_UNIT_ONE;
int idx = __pIsoList->GetCount() - INDEX_UNIT_ONE;
if (idx >= INDEX_UNIT_ZERO)
{
- r = __pCameraPresentationModel->GetValue(ISO_VALUE, regVal);
+ r = _pCameraPresentationModel->GetValue(ISO_VALUE, regVal);
if (regVal == INDEX_UNIT_ZERO)
{
{
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_ISO_LEVEL);
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_ISO_LEVEL);
}
if (r == E_SUCCESS)
IDS_MENU_ISO_800,
};
- r = __pCameraPresentationModel->GetValue(ISO_VALUE, regVal);
+ r = _pCameraPresentationModel->GetValue(ISO_VALUE, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (__pIsoList)
{
int selfPortraitEnable = 0;
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_PRIMARY )
{
- r = __pCameraPresentationModel->GetValue(PRIMARY_RESOLUTION_INDEX, __primaryCurrentResolutionIndex);
+ r = _pCameraPresentationModel->GetValue(PRIMARY_RESOLUTION_INDEX, __primaryCurrentResolutionIndex);
AppLogDebug("resolution index is %d",__primaryCurrentResolutionIndex);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
else
{
- r = __pCameraPresentationModel->GetValue(SECONDARY_RESOLUTION_INDEX, __secondaryCurrentResolutionIndex);
+ r = _pCameraPresentationModel->GetValue(SECONDARY_RESOLUTION_INDEX, __secondaryCurrentResolutionIndex);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
elementId = (index * MENU_TWO_ELEMENT);
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
strTmp = __pSettingGeneralMenuString[index][0];
{
int storageType = STORAGE_TYPE_PHONE;
- r = __pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, storageType);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
- if (storageType == STORAGE_TYPE_MEMORYCARD && __pCameraPresentationModel->IsStorageCardMounted() == false)
+ if (storageType == STORAGE_TYPE_MEMORYCARD && _pCameraPresentationModel->IsStorageCardMounted() == false)
{
- r = __pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
+ r = _pCameraPresentationModel->SetValue(STORAGE_TYPE, STORAGE_TYPE_PHONE);
TryCatch(r == E_SUCCESS, , "SetValue() fail[%s]", GetErrorMessage(r));
- __pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
+ _pCameraPresentationModel->SetStorageCardState(CameraPresentationModel::STORAGE_CARD_STATE_UNMOUNT);
}
- r = __pCameraPresentationModel->GetValue(arrRegStringSuppor[index], regVal);
+ r = _pCameraPresentationModel->GetValue(arrRegStringSuppor[index], regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
AppLogDebug("Setting Main Menu");
pAppResource->GetString(arrString[index], tmpString);
- r = __pCameraPresentationModel->GetValue(TIMER_INTERVAL, regVal);
+ r = _pCameraPresentationModel->GetValue(TIMER_INTERVAL, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (index == regVal)
String str = L"";
elementId = (index * MENU_TWO_ELEMENT);
- r = __pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, regVal);
+ r = _pCameraPresentationModel->GetValue(GUIDELINE_ENABLE, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (index == regVal)
String str = L"";
elementId = (index * MENU_TWO_ELEMENT);
- r = __pCameraPresentationModel->GetValue(STORAGE_TYPE, regVal);
+ r = _pCameraPresentationModel->GetValue(STORAGE_TYPE, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (index == regVal)
if (str.Equals(String(IDS_CAM_OPT_MEMORY_CARD)))
{
- if (__pCameraPresentationModel->IsStorageCardMounted() == false)
+ if (_pCameraPresentationModel->IsStorageCardMounted() == false)
{
r = pItem->AddElement(rectThreeTextItem, elementId, tmpString, FONT_SIZE_SETTING_SUB_MENU_ITEM, COLOR_SETTING_MENU_VALUE_DISABLE, COLOR_SETTING_MENU_VALUE_DISABLE, COLOR_SETTING_MENU_VALUE_DISABLE, true);
}
pAppResource = Application::GetInstance()->GetAppResource();
TryCatch(pAppResource != null, , "Failed to allocate memory for pAppResource");
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue Reg Fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
{
AppLogDebug("CAMERA_PRIMARY_SUPPORT_FLASH is not support");
- r = __pCameraPresentationModel->GetValue(FLASH_MODE_SECONDARY, flashMode);
+ r = _pCameraPresentationModel->GetValue(FLASH_MODE_SECONDARY, flashMode);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (flashMode != FLASH_MODE_OFF)
{
- r = __pCameraPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_SECONDARY, FLASH_MODE_OFF);
TryCatch(r == E_SUCCESS, , "SetValue Reg Fail[%s]", GetErrorMessage(r));
}
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
{
AppLogDebug("CAMERA_PRIMARY_SUPPORT_FLASH is not support");
- r = __pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
+ r = _pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, flashMode);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
if (flashMode != FLASH_MODE_OFF)
{
- r = __pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, FLASH_MODE_OFF);
+ r = _pCameraPresentationModel->SetValue(FLASH_MODE_PRIMARY, FLASH_MODE_OFF);
TryCatch(r == E_SUCCESS, , "SetValue Reg Fail[%s]", GetErrorMessage(r));
}
}
}
- r = __pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, regVal);
+ r = _pCameraPresentationModel->GetValue(FLASH_MODE_PRIMARY, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
switch (index)
elementId++;
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_SUPPORT_FLASH, value);
if (value == true && r == E_SUCCESS)
{
pAppResource = Application::GetInstance()->GetAppResource();
TryCatch(pAppResource != null, , "Failed to allocate memory for pAppResource");
- r = __pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
+ r = _pCameraPresentationModel->GetValue(SELF_PORTRAIT_ENABLE, selfPortraitEnable);
TryCatch(r == E_SUCCESS, , "GetValue Reg Fail[%s]", GetErrorMessage(r));
if (selfPortraitEnable == CameraPresentationModel::CAM_SELF_PORTRAIT_MODE_SECONDARY)
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_SECONDARY_WHITE_BALANCE);
if (r != E_SUCCESS)
{
- r =__pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_SECONDARY, REG_DEFAULT_VAULE_ZERO);
+ r =_pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_SECONDARY, REG_DEFAULT_VAULE_ZERO);
}
- r = __pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, regVal);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_SECONDARY, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
else
{
- r = __pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
+ r = _pCameraPresentationModel->GetMediaCapability(CAMERA_PRIMARY_WHITE_BALANCE);
if (r != E_SUCCESS)
{
- r =__pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_PRIMARY, REG_DEFAULT_VAULE_ZERO);
+ r =_pCameraPresentationModel->SetValue(WHITE_BALANCE_TYPE_PRIMARY, REG_DEFAULT_VAULE_ZERO);
}
- r = __pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, regVal);
+ r = _pCameraPresentationModel->GetValue(WHITE_BALANCE_TYPE_PRIMARY, regVal);
TryCatch(r == E_SUCCESS, , "GetValue() fail[%s]", GetErrorMessage(r));
}
}
void
-CameraForm::RemoveAllEventListener(void)
-{
- AppLogDebug("ENTER");
- RemoveOrientationEventListener(*this);
- RemoveTouchEventListener(*this);
- RemoveKeyEventListener(*this);
- AppLogDebug("EXIT");
-}
-
-void
CameraForm::UpdatePopUp(void)
{
bool doHidePopup = false;
r = ToggleCameraCamcorder(CAMERA_MODE_RECORD);
TryCatch(r == E_SUCCESS, , "ToggleCameraCamcorder [%s]", GetErrorMessage(r));
+ InitializeFlashMode();
}
}
__cameraMode = mode;
ret = pContentManager->Construct();
TryCatch(ret == E_SUCCESS, , "ContentManager->Construct() failed(%s)", GetErrorMessage(r));
+ AppLogDebug("latest content name is %ls",__lastestContentName.GetPointer());
r = ContentManager::ScanFile(__lastestContentName);
__CurrentVideoFileName = __lastestContentName;
removeFileName = Environment::GetExternalStoragePath() + STRING_CAMCORDER_TEMPORARY_FILE_EXT;
}
+ AppLogDebug("removeFileName is %ls",removeFileName.GetPointer());
AppLogDebug("RemoveVideoFile::GetRecorderState() = %d", __pVideoRecorder->GetState());
if (__pVideoRecorder->GetState()== RECORDER_STATE_RECORDING
|| __pVideoRecorder->GetState() == RECORDER_STATE_PAUSED
const int EXPOSURE_DEFAULT_VALUE = 4;
const int BRIGHTNESS_DEFAULT_VALUE = 4;
+const int MESSAGEBOX_DISPLAY_TIME_2_SEC = 2000;
+const int MESSAGEBOX_DISPLAY_TIME_3_SEC = 3000;
+
const wchar_t* SECTION_CAMERA = L"CAMERA_SETTING";
const wchar_t* SECTION_CAMCORDER = L"CAMCORDER_SETTING";
projects / apps / osp / Camera.git / commitdiff