src/FScl_CalendarImpl.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16 /**
  17  * @file                FScl_CalendarImpl.cpp
  18  * @brief               This is the implementation for _CalendarImpl class.
  19  *
  20  * This file contains definitions of @e _CalendarImpl class.
  21  */
  22
  23 #include <FBaseString.h>
  24 #include <FBaseSysLog.h>
  25 #include <FBaseUtilStringTokenizer.h>
  26 #include <FBaseInteger.h>
  27 #include <FSclCalendar.h>
  28 #include <FBase_StringConverter.h>
  29 #include "FScl_CalendarImpl.h"
  30 #include "FScl_RecordImpl.h"
  31 #include "FScl_CalendarbookDbConnector.h"
  32
  33 using namespace Tizen::Base;
  34 using namespace Tizen::Base::Utility;
  35 using namespace Tizen::Graphics;
  36
  37 namespace Tizen { namespace Social
  38 {
  39
  40 static const wchar_t* _COLOR_STRING_DELIMITER = L".";
  41 static const int _NUM_OF_COLOR_FACTOR = 3;
  42
  43 _CalendarImpl::_CalendarImpl(CalendarItemType itemType)
  44 {
  45         int errorCode = CALENDAR_ERROR_NONE;
  46         calendar_record_h calendarHandle = null;
  47
  48         result r = _CalendarbookDbConnector::Connect();
  49         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
  50
  51         errorCode = calendar_record_create(_calendar_book._uri, &calendarHandle);
  52         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  53
  54         calendar_record_set_int(calendarHandle, _calendar_book.store_type, _CalendarbookUtil::ConvertCalendarItemTypeToCSCalendarbookType(itemType));
  55
  56         __calendarRecord.ResetHandle(calendarHandle);
  57
  58 }
  59
  60 _CalendarImpl::_CalendarImpl(const _CalendarImpl& rhs)
  61 {
  62         int errorCode = CALENDAR_ERROR_NONE;
  63         calendar_record_h calendarHandle = null;
  64
  65         result r = _CalendarbookDbConnector::Connect();
  66         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
  67
  68         errorCode = calendar_record_clone(rhs.__calendarRecord.GetHandle(), &calendarHandle);
  69         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  70
  71         __calendarRecord.ResetHandle(calendarHandle);
  72 }
  73
  74 _CalendarImpl::~_CalendarImpl(void)
  75 {
  76         calendar_record_destroy(__calendarRecord.ReleaseHandle(), true);
  77
  78         result r = _CalendarbookDbConnector::Disconnect();
  79         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
  80 }
  81
  82 _CalendarImpl&
  83 _CalendarImpl::operator =(const _CalendarImpl& rhs)
  84 {
  85         if (this == &rhs)
  86         {
  87                 return *this;
  88         }
  89
  90         int errorCode = CALENDAR_ERROR_NONE;
  91         calendar_record_h calendarHandle = null;
  92
  93         errorCode = calendar_record_clone(rhs.__calendarRecord.GetHandle(), &calendarHandle);
  94         SysTryReturn(NID_SCL, errorCode == CALENDAR_ERROR_NONE, *this, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  95
  96         __calendarRecord.ResetHandle(calendarHandle);
  97
  98         return *this;
  99 }
 100
 101 String
 102 _CalendarImpl::GetName(void) const
 103 {
 104         char* pName = null;
 105
 106         calendar_record_get_str_p(__calendarRecord.GetHandle(), _calendar_book.name, &pName);
 107
 108         return String(pName);
 109 }
 110
 111 CalendarItemType
 112 _CalendarImpl::GetItemType(void) const
 113 {
 114         int storeType = 0;
 115         CalendarItemType calendarItemType = CALENDAR_ITEM_TYPE_EVENT_AND_TODO;
 116
 117         calendar_record_get_int(__calendarRecord.GetHandle(), _calendar_book.store_type, &storeType);
 118         switch (storeType)
 119         {
 120
 121                 case CALENDAR_BOOK_TYPE_EVENT | CALENDAR_BOOK_TYPE_TODO:
 122                         calendarItemType = CALENDAR_ITEM_TYPE_EVENT_AND_TODO;
 123                         break;
 124                 case CALENDAR_BOOK_TYPE_EVENT:
 125                         calendarItemType = CALENDAR_ITEM_TYPE_EVENT_ONLY;
 126                         break;
 127                 case CALENDAR_BOOK_TYPE_TODO:
 128                         calendarItemType = CALENDAR_ITEM_TYPE_TODO_ONLY;
 129                         break;
 130                 default:
 131                         calendarItemType = CALENDAR_ITEM_TYPE_EVENT_AND_TODO;
 132                         break;
 133         }
 134
 135         return calendarItemType;
 136 }
 137
 138 AccountId
 139 _CalendarImpl::GetAccountId(void) const
 140 {
 141         int accountId = 0;
 142         calendar_record_get_int(__calendarRecord.GetHandle(), _calendar_book.account_id, &accountId);
 143
 144         return accountId;
 145 }
 146
 147 result
 148 _CalendarImpl::GetColor(byte& red, byte& green, byte& blue) const
 149 {
 150         char* pColor = null;
 151         calendar_record_get_str_p(__calendarRecord.GetHandle(), _calendar_book.color, &pColor);
 152
 153         if (pColor == null || strlen(pColor) == 0)
 154         {
 155                 red = 0;
 156                 green = 0;
 157                 blue = 0;
 158
 159                 return E_DATA_NOT_FOUND;
 160         }
 161
 162         int tmpRed = 0;
 163         int tmpGreen = 0;
 164         int tmpBlue = 0;
 165
 166         String tmpString(pColor);
 167         String delim(_COLOR_STRING_DELIMITER);
 168         String token;
 169
 170         StringTokenizer strTok(tmpString, delim);
 171
 172         strTok.GetNextToken(token);
 173         Integer::Parse(token, tmpRed);
 174         strTok.GetNextToken(token);
 175         Integer::Parse(token, tmpGreen);
 176         strTok.GetNextToken(token);
 177         Integer::Parse(token, tmpBlue);
 178
 179         red = tmpRed;
 180         green = tmpGreen;
 181         blue = tmpBlue;
 182
 183         return E_SUCCESS;
 184 }
 185
 186 void
 187 _CalendarImpl::SetName(const String& name)
 188 {
 189         std::unique_ptr<char[]> pConvertedName(_StringConverter::CopyToCharArrayN(name));
 190         SysTryReturnVoidResult(NID_SCL, pConvertedName != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 191
 192         int errorCode = CALENDAR_ERROR_NONE;
 193         errorCode = calendar_record_set_str(__calendarRecord.GetHandle(), _calendar_book.name, pConvertedName.get());
 194         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 195 }
 196
 197 void
 198 _CalendarImpl::SetColor(byte red, byte green, byte blue)
 199 {
 200         String color;
 201         color.Append(red);
 202         color.Append(_COLOR_STRING_DELIMITER);
 203         color.Append(green);
 204         color.Append(_COLOR_STRING_DELIMITER);
 205         color.Append(blue);
 206         color.Append(_COLOR_STRING_DELIMITER);
 207         color.Append(255);      // alpha
 208
 209         std::unique_ptr<char[]> pConvertedColor(_StringConverter::CopyToCharArrayN(color));
 210         SysTryReturnVoidResult(NID_SCL, pConvertedColor != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 211
 212         int errorCode = CALENDAR_ERROR_NONE;
 213         errorCode = calendar_record_set_str(__calendarRecord.GetHandle(), _calendar_book.color, pConvertedColor.get());
 214         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 215 }
 216
 217 void
 218 _CalendarImpl::ClearColor(void)
 219 {
 220         String color;
 221
 222         std::unique_ptr<char[]> pConvertedColor(_StringConverter::CopyToCharArrayN(color));
 223         SysTryReturnVoidResult(NID_SCL, pConvertedColor != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 224
 225         int errorCode = CALENDAR_ERROR_NONE;
 226         errorCode = calendar_record_set_str(__calendarRecord.GetHandle(), _calendar_book.color, pConvertedColor.get());
 227         SysTryReturnVoidResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 228 }
 229
 230 void
 231 _CalendarImpl::SetAccountId(AccountId accountId)
 232 {
 233         calendar_record_set_int(__calendarRecord.GetHandle(), _calendar_book.account_id, accountId);
 234 }
 235
 236 void
 237 _CalendarImpl::SetRecordHandle(calendar_record_h calendarHandle)
 238 {
 239         __calendarRecord.ResetHandle(calendarHandle);
 240 }
 241
 242 calendar_record_h
 243 _CalendarImpl::GetRecordHandle(void) const
 244 {
 245         return __calendarRecord.GetHandle();
 246 }
 247
 248 Calendar*
 249 _CalendarImpl::CreateDefaultInstanceN(void)
 250 {
 251         return new (std::nothrow) Calendar(CALENDAR_ITEM_TYPE_EVENT_AND_TODO);
 252 }
 253
 254 _CalendarImpl*
 255 _CalendarImpl::GetInstance(Calendar& calendar)
 256 {
 257         return calendar.__pCalendarImpl;
 258 }
 259
 260 const _CalendarImpl*
 261 _CalendarImpl::GetInstance(const Calendar& calendar)
 262 {
 263         return calendar.__pCalendarImpl;
 264 }
 265
 266 }}      // Tizen::Social