src/data/MediadataImpl.cpp

   1 /*
   2 * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   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 #include <cstdio>
  18 #include <cstdlib>
  19 #include <cstring>
  20
  21 #include <AppCommon.h>
  22 #include "common.h"
  23 #include "FileList.h"
  24 #include "FileInfo.h"
  25 #include "DirectoryInfo.h"
  26 #include "Mediadata.h"
  27 #include "MediadataImpl.h"
  28
  29 struct SMediadataImpl {
  30         Eina_List *filelist;
  31
  32         filter_h filter;
  33         int source_type;
  34         int media_type;
  35 };
  36
  37 bool CMediadataImpl::m_CreateFilter(int source_type, int media_type)
  38 {
  39         char buf[1024];
  40         int ret;
  41
  42         struct SPairSources {
  43                 sources source;
  44                 const char* string;
  45         } source_condn[] = {
  46                 { E_ALL, "" },
  47                 { E_TV, "(MEDIA_STORAGE_TYPE=0)" },
  48                 { E_USB, "(MEDIA_STORAGE_TYPE=1)" }
  49         };
  50         ASSERT(source_condn[E_ALL].source == E_ALL &&
  51                 source_condn[E_TV].source == E_TV &&
  52                 source_condn[E_USB].source == E_USB);
  53
  54         struct SPairMedia {
  55                 enum groups groups;
  56                 const char* string;
  57         } media_condn[] = {
  58                 { E_GRP_ALL, "" },
  59                 { E_GRP_PHOTO, "(MEDIA_TYPE=0)" },
  60                 { E_GRP_VIDEO, "(MEDIA_TYPE=1)" },
  61                 { E_GRP_MUSIC, "(MEDIA_TYPE=3)" }
  62         };
  63         ASSERT(media_condn[E_GRP_ALL].groups == E_GRP_ALL &&
  64                 media_condn[E_GRP_PHOTO].groups == E_GRP_PHOTO &&
  65                 media_condn[E_GRP_VIDEO].groups == E_GRP_VIDEO &&
  66                 media_condn[E_GRP_MUSIC].groups == E_GRP_MUSIC);
  67
  68         ret = media_filter_create(&m->filter);
  69         if (ret != MEDIA_CONTENT_ERROR_NONE) {
  70                 _ERR("Media Filter Creation Failed");
  71                 return false;
  72         }
  73
  74         _DBG("media: %d, source: %d", media_type, source_type);
  75         if (media_type == E_GRP_ALL) {
  76                 if (source_type == E_ALL)
  77                         return true;
  78
  79                 snprintf(buf, sizeof(buf), "%s", source_condn[source_type].string);
  80         }
  81         else {
  82                 if (source_type == E_ALL)
  83                         snprintf(buf, sizeof(buf), "%s", media_condn[media_type].string);
  84                 else
  85                         snprintf(buf, sizeof(buf), "%s AND %s", source_condn[source_type].string, media_condn[media_type].string);
  86         }
  87
  88         media_filter_set_condition(m->filter, buf, MEDIA_CONTENT_COLLATE_RTRIM);
  89
  90         return true;
  91 }
  92
  93 void CMediadataImpl::m_DestroyFilter(filter_h filter)
  94 {
  95         if (!filter)
  96                 return;
  97
  98         int r = media_filter_destroy(filter);
  99         ASSERT(r == MEDIA_CONTENT_ERROR_NONE);
 100 }
 101
 102 bool CMediadataImpl::sm_CbMediaInfo(media_info_h media, void *dt)
 103 {
 104         CMediadataImpl* root = (CMediadataImpl*)dt;
 105
 106         bool ret = false;
 107         if (root)
 108                 ret = root->m_OnMediaInfo(media);
 109
 110         return ret;
 111 }
 112
 113 bool CMediadataImpl::m_OnMediaInfo(media_info_h media)
 114 {
 115         CFileInfo *pInfo = NULL;
 116
 117         _CREATE_BEGIN{
 118                 _CHECK(pInfo = new CFileInfo)
 119                 _CHECK(pInfo->Create())
 120                 _CHECK(pInfo->SetLoadInfo(media))
 121                 _CHECK(pInfo->Load())
 122                 _WHEN_SUCCESS{
 123                         m->filelist = eina_list_append(m->filelist, pInfo);
 124                 }
 125                 _CHECK_FAIL{}
 126                 _CHECK_FAIL{}
 127                 _CHECK_FAIL{ pInfo->Destroy(); }
 128                 _CHECK_FAIL{ delete pInfo; pInfo = NULL; }
 129         }_CREATE_END_AND_CATCH{ return false; }
 130
 131         return true;
 132 }
 133
 134 bool CMediadataImpl::sm_CbFolderInfo(media_folder_h folder, void* data)
 135 {
 136         CMediadataImpl* root = (CMediadataImpl*)data;
 137
 138         _DBG("root: %x, m: %x", root, root->m);
 139         bool ret = false;
 140         if (root)
 141                 ret = root->m_OnFolderInfo(folder);
 142
 143         return ret;
 144 }
 145
 146 bool CMediadataImpl::m_OnFolderInfo(media_folder_h folder)
 147 {
 148         CDirectoryInfo *pDir = NULL;
 149
 150         _CREATE_BEGIN{
 151                 _CHECK(pDir = new CDirectoryInfo)
 152                 _CHECK(pDir->Create())
 153                 _CHECK(pDir->SetLoadInfo(m->filter, folder))
 154                 _CHECK(pDir->Load())
 155                 _WHEN_SUCCESS{
 156                         Add(m->media_type, pDir);
 157                 }
 158                 _CHECK_FAIL{}
 159                 _CHECK_FAIL{}
 160                 _CHECK_FAIL{ pDir->Destroy(); }
 161                 _CHECK_FAIL{ delete pDir; pDir = NULL; }
 162         }_CREATE_END_AND_CATCH{ return false; }
 163
 164         return true;
 165 }
 166
 167 bool CMediadataImpl::m_GetMediaList(const char *folderid)
 168 {
 169         t_Remove(&m->filelist);
 170
 171         int r = media_folder_foreach_media_from_db(folderid, m->filter, sm_CbMediaInfo, this);
 172         if (r != MEDIA_CONTENT_ERROR_NONE) {
 173                 _ERR("Media folder foreach folder from db failed");
 174         }
 175         return r == MEDIA_CONTENT_ERROR_NONE ? true : false;
 176 }
 177
 178 void CMediadataImpl::m_GetFolderList(void)
 179 {
 180         int r;
 181         _DBG("START: this: 0x%x", this);
 182         r = media_folder_foreach_folder_from_db(m->filter, sm_CbFolderInfo, this);
 183         if (r != MEDIA_CONTENT_ERROR_NONE)
 184                 _ERR("Media folder foreach folder from db failed");
 185         _DBG("END");
 186 }
 187
 188 void CMediadataImpl::m_UpdateFolderLists(void)
 189 {
 190         int type;
 191
 192         RemoveAll();
 193
 194         for (type = E_GRP_ALL; type <= E_GRP_MUSIC; type++) {
 195                 _DBG("==================================================");
 196                 m->media_type = type;
 197
 198                 bool r = m_CreateFilter(m->source_type, m->media_type);
 199                 if (!r) {
 200                         _ERR("Media Filter Creation Failed");
 201                         continue;
 202                 }
 203
 204                 m_GetFolderList();
 205
 206                 m_DestroyFilter(m->filter);
 207                 m->filter = NULL;
 208                 _DBG("==================================================");
 209         }
 210 }
 211
 212 bool CMediadataImpl::Create(void)
 213 {
 214         if (m)
 215                 return false;
 216
 217         _CREATE_BEGIN{
 218                 _CHECK(m = new SMediadataImpl)
 219                 _CHECK(media_content_connect() == MEDIA_CONTENT_ERROR_NONE)
 220                 _WHEN_SUCCESS{
 221
 222                 }
 223                 _CHECK_FAIL{ media_content_disconnect(); }
 224                 _CHECK_FAIL{ delete m; m = NULL; }
 225         } _CREATE_END_AND_CATCH{ return false; }
 226
 227         m->source_type = E_GRP_NONE;
 228         m->media_type  = E_GRP_ALL;
 229         m->filelist = NULL;
 230
 231         return true;
 232 }
 233
 234 void CMediadataImpl::Destroy(void)
 235 {
 236         if (!m)
 237                 return;
 238
 239         _DBG("#########################");
 240
 241         t_Remove(&m->filelist);
 242         RemoveAll();
 243
 244         int r;
 245         r = media_content_disconnect();
 246         if (r != MEDIA_CONTENT_ERROR_NONE)
 247                 _ERR("Media Content Connect Failed");
 248
 249         delete m;
 250         m = NULL;
 251 }
 252
 253 bool CMediadataImpl::GetMediaList(const char* folderid, int media_type, int source_type, Eina_List **list)
 254 {
 255         ASSERT(0 <= media_type && media_type <= t_Max());
 256
 257         if (!m)
 258                 return false;
 259
 260         /* Inner Level */
 261         m->media_type = media_type;
 262         m->source_type = source_type;
 263
 264         bool r = m_CreateFilter(m->source_type, m->media_type);
 265         if (!r) {
 266                 _ERR("Media Filter Creation Failed");
 267                 return false;
 268         }
 269
 270         r = m_GetMediaList(folderid);
 271
 272         m_DestroyFilter(m->filter);
 273         m->filter = NULL;
 274
 275         if (m->filelist) {
 276                 *list = eina_list_clone(m->filelist);
 277                 r = true;
 278         }
 279
 280         return r;
 281 }
 282
 283 bool CMediadataImpl::GetFolderList(int media_type, int source_type, Eina_List **list)
 284 {
 285         ASSERT(0 <= media_type && media_type <= t_Max());
 286
 287         if (!m)
 288                 return false;
 289
 290         _DBG("sourceType: %d, m->source_Type: %d", source_type, m->source_type);
 291         /* Outer level */
 292         if (source_type != m->source_type) {
 293                 m->source_type = source_type;
 294                 m_UpdateFolderLists();
 295         }
 296
 297         *list = Clone(media_type);
 298         return true;
 299 }