src/FCnt_ImageContentInfoImpl.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                FCnt_ImageContentInfoImpl.cpp
  18  * @brief               This is the implementation file for the %_ImageContentInfoImpl class.
  19  *
  20  * This file contains implementation of the %_ImageContentInfoImpl class.
  21  */
  22
  23 #include <FBaseSysLog.h>
  24 #include <FIoFile.h>
  25 #include <FIoDirectory.h>
  26 #include <FSysEnvironment.h>
  27 #include <FIo_FileImpl.h>
  28 #include <FApp_AppInfo.h>
  29 #include "FCnt_ImageContentInfoImpl.h"
  30
  31 using namespace std;
  32 using namespace Tizen::App;
  33 using namespace Tizen::Base;
  34 using namespace Tizen::Io;
  35 using namespace Tizen::Locations;
  36 using namespace Tizen::System;
  37
  38 namespace Tizen { namespace Content
  39 {
  40
  41 _ImageContentInfoImpl::_ImageContentInfoImpl(void)
  42         : __width(0)
  43         , __height(0)
  44         , __isBurst(false)
  45         , __orientationType(IMAGE_ORIENTATION_TYPE_UNKNOWN)
  46         , __title(L"")
  47         , __burstShotId(L"")
  48 {
  49
  50 }
  51
  52 _ImageContentInfoImpl::~_ImageContentInfoImpl(void)
  53 {
  54
  55 }
  56
  57 _ImageContentInfoImpl*
  58 _ImageContentInfoImpl::GetInstance(ImageContentInfo& imageContentInfo)
  59 {
  60         return imageContentInfo.__pImageContentInfoImpl;
  61 }
  62
  63 const _ImageContentInfoImpl*
  64 _ImageContentInfoImpl::GetInstance(const ImageContentInfo& imageContentInfo)
  65 {
  66         return imageContentInfo.__pImageContentInfoImpl;
  67 }
  68
  69 result
  70 _ImageContentInfoImpl::Construct(const String& contentPath, const String& thumbnailPath, bool setGps)
  71 {
  72         result r = E_SUCCESS;
  73         int contentLength = 0;
  74         FileAttributes attribute;
  75
  76         // checks parameters
  77         contentLength = contentPath.GetLength();
  78         SysTryReturnResult(NID_CNT, _FileImpl::IsMediaPath(contentPath), E_INVALID_ARG,
  79                         "The contentPath should start with /Media or /Storagecard/Media.");
  80         SysTryReturnResult(NID_CNT, File::IsFileExist(contentPath), E_FILE_NOT_FOUND,
  81                         "The file corresponding to contentPath could not be found.");
  82
  83         if (!thumbnailPath.IsEmpty())
  84         {
  85                 SysLog(NID_CNT,
  86                                 "The thumbnailPath is not supported but you can get the thumbnail managed by Tizen from ContentInfo::GetThumbnailN().");
  87         }
  88
  89         if (setGps)
  90         {
  91                 SysLog(NID_CNT, "The setGps is not supported.");
  92         }
  93
  94         SetContentPath(contentPath);
  95         SetContentType(CONTENT_TYPE_IMAGE);
  96
  97         return r;
  98 }
  99
 100 result
 101 _ImageContentInfoImpl::Construct(const String* pContentPath)
 102 {
 103         result r = E_SUCCESS;
 104
 105         if (pContentPath != null)
 106         {
 107                 String contentPath(*pContentPath);
 108
 109                 if (!_AppInfo::IsOspCompat())
 110                 {
 111                         if (!(contentPath.StartsWith(Environment::GetMediaPath(), 0)
 112                                 || contentPath.StartsWith(Environment::GetExternalStoragePath(), 0)))
 113                         {
 114                                 SysLogException(NID_CNT, E_INVALID_ARG, "[E_INVALID_ARG] The path is not supported.");
 115                                 return E_INVALID_ARG;
 116                         }
 117                 }
 118                 else
 119                 {
 120                         // prior to 2.0
 121                         if (contentPath.StartsWith(OSP_MEDIA_PHONE, 0))
 122                         {
 123                                 // Because the content path is saved like /opt/media or /opt/storage/sdcard/ in SLP database,
 124                                 // it should be converted in 2.0.
 125                                 r = contentPath.Replace(OSP_MEDIA_PHONE, Environment::GetMediaPath());
 126                                 SysTryReturnResult(NID_CNT, !IsFailed(r), E_INVALID_ARG, "Construct() failed.");
 127                         }
 128                         else if (contentPath.StartsWith(OSP_MEDIA_MMC, 0))
 129                         {
 130                                 r = contentPath.Replace(OSP_MEDIA_MMC, Environment::GetExternalStoragePath());
 131                                 SysTryReturnResult(NID_CNT, !IsFailed(r), E_INVALID_ARG, "Construct() failed.");
 132                         }
 133                         else
 134                         {
 135                                 SysLogException(NID_CNT, E_INVALID_ARG,
 136                                                 "[E_INVALID_ARG] The contentPath should start with /Media or /Storagecard/Media.");
 137                                 return E_INVALID_ARG;
 138                         }
 139                 }
 140
 141                 int length = contentPath.GetLength();
 142                 SysTryReturnResult(NID_CNT, length != 0, E_INVALID_ARG,
 143                                 "The length of pContentPath is 0.");
 144                 SysTryReturnResult(NID_CNT, File::IsFileExist(contentPath), E_FILE_NOT_FOUND,
 145                                 "The file corresponding to pContentPath could not be found.");
 146
 147                 SetContentPath(contentPath);
 148                 SetContentType(CONTENT_TYPE_IMAGE);
 149         }
 150         else
 151         {
 152                 SetContentType(CONTENT_TYPE_IMAGE);
 153         }
 154
 155         return r;
 156 }
 157
 158 int
 159 _ImageContentInfoImpl::GetWidth(void) const
 160 {
 161         return __width;
 162 }
 163
 164 int
 165 _ImageContentInfoImpl::GetHeight(void) const
 166 {
 167         return __height;
 168 }
 169
 170 ImageOrientationType
 171 _ImageContentInfoImpl::GetOrientation(void) const
 172 {
 173         return __orientationType;
 174 }
 175
 176 DateTime
 177 _ImageContentInfoImpl::GetImageTakenDate(void) const
 178 {
 179         return __takenDate;
 180 }
 181
 182 String
 183 _ImageContentInfoImpl::GetTitle(void) const
 184 {
 185         if (__title.IsEmpty())
 186         {
 187                 SysLog(NID_CNT, "Title is empty.");
 188                 return L"Unknown";
 189         }
 190
 191         return __title;
 192 }
 193
 194 bool
 195 _ImageContentInfoImpl::IsBurstShot(void) const
 196 {
 197         return __isBurst;
 198 }
 199
 200 String
 201 _ImageContentInfoImpl::GetBurstShotId(void) const
 202 {
 203         return __burstShotId;
 204 }
 205
 206 void
 207 _ImageContentInfoImpl::SetWidth(int width)
 208 {
 209         __width = width;
 210 }
 211
 212 void
 213 _ImageContentInfoImpl::SetHeight(int height)
 214 {
 215         __height = height;
 216 }
 217
 218 void
 219 _ImageContentInfoImpl::SetTitle(const String& title)
 220 {
 221         __title = title;
 222 }
 223
 224 void
 225 _ImageContentInfoImpl::SetOrientation(const ImageOrientationType& orientationType)
 226 {
 227         __orientationType = orientationType;
 228 }
 229
 230 void
 231 _ImageContentInfoImpl::SetImageTakenDate(const DateTime& takenDate)
 232 {
 233         __takenDate = takenDate;
 234 }
 235
 236 void
 237 _ImageContentInfoImpl::SetBurstShot(const bool isBurst)
 238 {
 239         __isBurst = isBurst;
 240 }
 241
 242 void
 243 _ImageContentInfoImpl::SetBurstShotId(const String& burstShotId)
 244 {
 245         __burstShotId = burstShotId;
 246 }
 247
 248 }}