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