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