src/grid/grid_movie.c

   1 /*
   2  * Copyright (c) 2015 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 <Elementary.h>
  18 #include <media_content.h>
  19 #include <app_debug.h>
  20 #include <app_contents.h>
  21 #include <app_media.h>
  22 #include <gridmgr.h>
  23 #include <inputmgr.h>
  24 #include <viewmgr.h>
  25
  26 #include "define.h"
  27 #include "view.h"
  28 #include "data/datamgr.h"
  29 #include "grid/grid.h"
  30 #include "util/util.h"
  31
  32 #define STR_GENRE_NAME "Genre"
  33
  34 static void _create_thumbnail_completed_cb(media_content_error_e err,
  35                         const char *path, void *user_data)
  36 {
  37         Elm_Object_Item *it;
  38         app_media *am;
  39
  40         if (!user_data)
  41                 return;
  42
  43         it = user_data;
  44
  45         media_content_connect();
  46
  47         am = elm_object_item_data_get(it);
  48
  49         app_media_update(am);
  50
  51         elm_gengrid_item_fields_update(it, PART_ELM_SWALLOW_THUMBNAIL,
  52                                 ELM_GENGRID_ITEM_FIELD_CONTENT);
  53
  54         media_content_disconnect();
  55 }
  56
  57 static char *_media_text_get(void *data, Evas_Object *obj, const char *part)
  58 {
  59         app_media *am;
  60         app_media_info *info;
  61
  62         if (!data)
  63                 return NULL;
  64
  65         am = data;
  66
  67         info = app_media_get_info(am);
  68         if (!info) {
  69                 _ERR("failed to get media info");
  70                 return NULL;
  71         }
  72
  73         return strdup(info->title);
  74 }
  75
  76 static Evas_Object *_media_content_get(void *data, Evas_Object *obj,
  77                         const char *part)
  78 {
  79         Evas_Object *eo;
  80         app_media *am;
  81         app_media_info *info;
  82         struct color_data bg;
  83
  84         if (!data)
  85                 return NULL;
  86
  87         am = data;
  88
  89         info = app_media_get_info(am);
  90         if (!info) {
  91                 _ERR("failed to get media info");
  92                 return NULL;
  93         }
  94
  95         eo = NULL;
  96         if (!strcmp(part, PART_ELM_SWALLOW_THUMBNAIL)) {
  97                 if (!info->thumbnail_path) {
  98                         util_create_thumbnail(obj, am,
  99                                 _create_thumbnail_completed_cb);
 100                         return NULL;
 101                 }
 102
 103                 eo = util_add_image(obj, info->thumbnail_path);
 104                 if (!eo) {
 105                         _ERR("failed to create image object");
 106                         return NULL;
 107                 }
 108         } else if (!strcmp(part, PART_ELM_SWALLOW_FAVORITE)) {
 109                 if (!info->favorite)
 110                         return NULL;
 111
 112                 eo = util_add_image(obj, IMAGE_THUMBNAIL_FAVORITE);
 113                 if (!eo) {
 114                         _ERR("failed to create image object");
 115                         return NULL;
 116                 }
 117         } else if (!strcmp(part, PART_ELM_SWALLOW_TEXTBG)) {
 118                 eo = evas_object_rectangle_add(obj);
 119                 if (!eo) {
 120                         _ERR("failed to create rectangle object");
 121                         return NULL;
 122                 }
 123
 124                 app_contents_get_color(info->title, NULL, &bg);
 125                 evas_object_color_set(eo, bg.r, bg.g, bg.b, bg.a);
 126         }
 127
 128         if (eo)
 129                 evas_object_show(eo);
 130
 131         return eo;
 132 }
 133
 134 static char *_group_text_get(void *data, Evas_Object *obj, const char *part)
 135 {
 136         struct group_info *gi;
 137         char buf[32];
 138         int cnt;
 139
 140         if (!data)
 141                 return NULL;
 142
 143         gi = data;
 144
 145         if (!strcmp(part, PART_ELM_TEXT_TITLE))
 146                 return strdup(gi->name);
 147         else if (!strcmp(part, PART_ELM_TEXT_COUNT)) {
 148                 cnt = eina_list_count(gi->list);
 149                 snprintf(buf, sizeof(buf), "%d", cnt);
 150                 return strdup(buf);
 151         }
 152
 153         return NULL;
 154 }
 155
 156 static Evas_Object *_group_content_get(void *data, Evas_Object *obj,
 157                         const char *part)
 158 {
 159         Evas_Object *eo;
 160         struct group_info *gi;
 161         struct color_data bg;
 162
 163         if (!data)
 164                 return NULL;
 165
 166         gi = data;
 167
 168         eo = NULL;
 169         if (!strcmp(part, PART_ELM_SWALLOW_BG)) {
 170                 eo = evas_object_rectangle_add(obj);
 171                 if (!eo) {
 172                         _ERR("failed to create rectangle object");
 173                         return NULL;
 174                 }
 175
 176                 app_contents_get_color(gi->name, &bg, NULL);
 177                 evas_object_color_set(eo, bg.r, bg.g, bg.b, bg.a);
 178
 179                 evas_object_show(eo);
 180         }
 181
 182         return eo;
 183 }
 184
 185 static Eina_List *_get_name_list(struct datamgr *dmgr)
 186 {
 187         if (!dmgr) {
 188                 _ERR("invalid argument");
 189                 return NULL;
 190         }
 191
 192         return dmgr->ops->get_group(dmgr->handle, E_GROUP_MEDIA_NAME, NULL);
 193 }
 194
 195 static Eina_List *_get_genre_list(struct datamgr *dmgr)
 196 {
 197         Eina_List *list;
 198         struct group_info *gi;
 199
 200         if (!dmgr) {
 201                 _ERR("invalid argument");
 202                 return NULL;
 203         }
 204
 205         gi = calloc(1, sizeof(*gi));
 206         if (!gi) {
 207                 _ERR("failed to allocate memory");
 208                 return NULL;
 209         }
 210
 211         gi->name = STR_GENRE_NAME;
 212         gi->list = dmgr->ops->get_group(dmgr->handle,
 213                                 E_GROUP_MEDIA_GENRE, NULL);
 214
 215         list = NULL;
 216         list = eina_list_append(list, gi);
 217
 218         return list;
 219 }
 220
 221 static Eina_List *_get_date_list(struct datamgr *dmgr)
 222 {
 223         if (!dmgr) {
 224                 _ERR("invalid argument");
 225                 return NULL;
 226         }
 227
 228         return dmgr->ops->get_group(dmgr->handle, E_GROUP_MEDIA_DATE, NULL);
 229 }
 230
 231 static void _free_media_list(struct datamgr *dmgr, Eina_List *list)
 232 {
 233         if (!dmgr) {
 234                 _ERR("invalid argument");
 235                 return;
 236         }
 237
 238         dmgr->ops->free_group(list);
 239 }
 240
 241 static void _free_group_list(struct datamgr *dmgr, Eina_List *list)
 242 {
 243         struct group_info *gi;
 244
 245         if (!dmgr) {
 246                 _ERR("invalid argument");
 247                 return;
 248         }
 249
 250         EINA_LIST_FREE(list, gi) {
 251                 dmgr->ops->free_group(gi->list);
 252                 free(gi);
 253         }
 254 }
 255
 256 static void _get_media_info(struct datamgr *dmgr, Eina_List *list,
 257                         char *str, int size)
 258 {
 259         int cnt;
 260
 261         cnt = dmgr->ops->get_count(dmgr->handle, E_FILE_VIDEO);
 262         if (cnt < 0) {
 263                 _ERR("failed to get media count");
 264                 cnt = 0;
 265         }
 266
 267         snprintf(str, size, "%d Movies", cnt);
 268 }
 269
 270 static void _get_genre_info(struct datamgr *dmgr, Eina_List *list,
 271                         char *str, int size)
 272 {
 273         struct group_info *gi;
 274         int cnt;
 275
 276         gi = eina_list_nth(list, 0);
 277         cnt = eina_list_count(gi->list);
 278
 279         snprintf(str, size, "%d Genre", cnt);
 280 }
 281
 282 static void _key_down_cb(void *data, Elm_Object_Item *it,
 283                         Evas_Event_Key_Down *ev)
 284 {
 285         struct view_update_data vdata;
 286         struct datamgr *dmgr;
 287         app_media *am;
 288
 289         if (!data || !ev) {
 290                 _ERR("invalid argument");
 291                 return;
 292         }
 293
 294         dmgr = data;
 295
 296         if (!strcmp(ev->keyname, KEY_MENU) ||
 297                 !strcmp(ev->keyname, KEY_CONTEXT_MENU)) {
 298                 am = elm_object_item_data_get(it);
 299                 if (!am) {
 300                         _ERR("failed to get app media");
 301                         return;
 302                 }
 303
 304                 vdata.list = dmgr->ops->get_list(dmgr->handle,
 305                                         E_LIST_MEDIA, NULL);
 306                 vdata.index = util_get_media_index(vdata.list, am);
 307
 308                 viewmgr_update_view(VIEW_ACTION_MENU, UPDATE_CONTENT, &vdata);
 309                 viewmgr_show_view(VIEW_ACTION_MENU);
 310         }
 311 }
 312
 313 static void _media_selected_cb(void *data, Elm_Object_Item *it)
 314 {
 315         struct view_update_data vdata;
 316         struct datamgr *dmgr;
 317         app_media *am;
 318
 319         if (!data || !it) {
 320                 _ERR("invalid argument");
 321                 return;
 322         }
 323
 324         dmgr = data;
 325
 326         am = elm_object_item_data_get(it);
 327         if (!am) {
 328                 _ERR("failed to get app media");
 329                 return;
 330         }
 331
 332         vdata.list = dmgr->ops->get_list(dmgr->handle, E_LIST_MEDIA, NULL);
 333         vdata.index = util_get_media_index(vdata.list, am);
 334         vdata.id = VIEW_BASE;
 335
 336         viewmgr_update_view(VIEW_VIEWER, UPDATE_CONTENT, &vdata);
 337         viewmgr_push_view(VIEW_VIEWER);
 338 }
 339
 340 static void _genre_selected_cb(void *data, Elm_Object_Item *it)
 341 {
 342         struct view_update_data vdata;
 343         struct group_info *gi;
 344
 345         if (!it) {
 346                 _ERR("invalid argument");
 347                 return;
 348         }
 349
 350         gi = elm_object_item_data_get(it);
 351         if (!gi) {
 352                 _ERR("failed to get group info");
 353                 return;
 354         }
 355
 356         vdata.list = gi->list;
 357         vdata.index = E_DETAIL_MOVIE_GENRE;
 358         vdata.id = gi->name;
 359
 360         viewmgr_update_view(VIEW_DETAIL, UPDATE_CONTENT, &vdata);
 361         viewmgr_push_view(VIEW_DETAIL);
 362 }
 363
 364 static struct grid_class _gclass[] = {
 365         [E_MOVIE_NAME] = {
 366                 .item_style = STYLE_MOVIE_NAME,
 367                 .text_get = _media_text_get,
 368                 .content_get = _media_content_get
 369         },
 370         [E_MOVIE_GENRE] = {
 371                 .item_style = STYLE_MOVIE_GENRE,
 372                 .text_get = _group_text_get,
 373                 .content_get = _group_content_get
 374         },
 375         [E_MOVIE_DATE] = {
 376                 .item_style = STYLE_MOVIE_NAME,
 377                 .text_get = _media_text_get,
 378                 .content_get = _media_content_get
 379         },
 380         /* Other view mode class will be added later */
 381 };
 382
 383 static struct grid_data _gdata[] = {
 384         [E_MOVIE_NAME] = {
 385                 .item_x = MOVIE_NAME_ITEM_X,
 386                 .item_y = MOVIE_NAME_ITEM_Y,
 387                 .item_num = MOVIE_NAME_ITEM_NUM,
 388                 .grid_padding = MOVIE_NAME_GRID_PADDING,
 389                 .gclass = &_gclass[E_MOVIE_NAME],
 390                 .get_item_list = _get_name_list,
 391                 .free_item_list = _free_media_list,
 392                 .get_item_info = _get_media_info,
 393                 .key_down_cb = _key_down_cb,
 394                 .selected_cb = _media_selected_cb
 395         },
 396         [E_MOVIE_GENRE] = {
 397                 .item_x = MOVIE_GENRE_ITEM_X,
 398                 .item_y = MOVIE_GENRE_ITEM_Y,
 399                 .item_num = MOVIE_GENRE_ITEM_NUM,
 400                 .grid_padding = MOVIE_GENRE_GRID_PADDING,
 401                 .gclass = &_gclass[E_MOVIE_GENRE],
 402                 .get_item_list = _get_genre_list,
 403                 .free_item_list = _free_group_list,
 404                 .get_item_info = _get_genre_info,
 405                 .selected_cb = _genre_selected_cb
 406         },
 407         [E_MOVIE_DATE] = {
 408                 .item_x = MOVIE_NAME_ITEM_X,
 409                 .item_y = MOVIE_NAME_ITEM_Y,
 410                 .item_num = MOVIE_NAME_ITEM_NUM,
 411                 .grid_padding = MOVIE_NAME_GRID_PADDING,
 412                 .gclass = &_gclass[E_MOVIE_DATE],
 413                 .get_item_list = _get_date_list,
 414                 .free_item_list = _free_media_list,
 415                 .get_item_info = _get_media_info,
 416                 .key_down_cb = _key_down_cb,
 417                 .selected_cb = _media_selected_cb
 418         },
 419         /* Other view mode data will be added later */
 420 };
 421
 422 struct grid_data *get_movie_grid_data(int type)
 423 {
 424         if (type < 0 || type >= E_MOVIE_MAX) {
 425                 _ERR("invalid argument");
 426                 return NULL;
 427         }
 428
 429         return &_gdata[type];
 430 }