src/widget/mp-minicontroller.c

   1 /*
   2  * Copyright 2012         Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.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.tizenopensource.org/license
   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
  18 #include <minicontrol-provider.h>
  19 #include "mp-minicontroller.h"
  20 #include "mp-player-control.h"
  21 #include "mp-play.h"
  22 #include "Ecore.h"
  23 #include "mp-player-mgr.h"
  24 #include "mp-util.h"
  25 #include "mp-widget.h"
  26 #include "mp-setting-ctrl.h"
  27
  28 #define MINI_CONTROLLER_WIDTH (720)
  29 #define MINI_CONTROLLER_WIDTH_LANDSCAPE (1280)
  30 #define MINI_CONTROLLER_HEIGHT (170)
  31 #define WL_INDI_H 27            //Window Layout Indicator Height
  32 #define PAUSE_TIME_OUT 120
  33
  34 #define CTR_EDJ_SIG_SRC "ctrl_edj"
  35 #define CTR_PROG_SIG_SRC "ctrl_prog"
  36
  37 #define BUFFER_MAX              256
  38
  39 static void _minicontroller_action_cb(void *data, Evas_Object * obj, const char *emission, const char *source);
  40 static Evas_Object *_load_edj(Evas_Object * parent, const char *file, const char *group);
  41 static Evas_Object *_create_bgimg(Evas_Object * parent);
  42 static Evas_Object *_load_minicontroller(struct appdata *ad);
  43
  44 static inline void
  45 _mp_minicontroller_update_elapsed_time(struct appdata *ad)
  46 {
  47         MP_CHECK(ad);
  48         MP_CHECK(ad->minicontroller_layout);
  49
  50
  51         int sec = mp_player_mgr_get_position() / 1000;
  52         int min = sec / 60;
  53         sec = sec % 60;
  54
  55         char *time_text = g_strdup_printf("%02d:%02d", min, sec);
  56         if (time_text) {
  57                 edje_object_part_text_set(_EDJ(ad->minicontroller_layout), "elm.elapsed_time", time_text);
  58                 free(time_text);
  59                 time_text = NULL;
  60         }
  61 }
  62
  63 static Eina_Bool
  64 _minicontroller_update_progresstime_cb(void *data)
  65 {
  66         struct appdata *ad = data;
  67         mp_retvm_if(ad == NULL, ECORE_CALLBACK_CANCEL, "appdata is NULL");
  68
  69         if (ad->player_state == PLAY_STATE_PLAYING)
  70         {
  71                 _mp_minicontroller_update_elapsed_time(ad);
  72         }
  73
  74         return ECORE_CALLBACK_RENEW;
  75 }
  76
  77 static void
  78 _minicontroller_progress_timer_add(void *data)
  79 {
  80         struct appdata *ad = data;
  81         mp_retm_if(ad == NULL, "appdata is NULL");
  82         DEBUG_TRACE();
  83
  84         mp_ecore_timer_del(ad->minicon_progress_timer);
  85
  86         _mp_minicontroller_update_elapsed_time(ad);
  87         if (ad->player_state == PLAY_STATE_PLAYING)
  88                 ad->minicon_progress_timer = ecore_timer_add(1.0, _minicontroller_update_progresstime_cb, ad);
  89 }
  90
  91 static void
  92 _minicontroller_action_cb(void *data, Evas_Object * obj, const char *emission, const char *source)
  93 {
  94         DEBUG_TRACE("emission: %s, source: %s\n", emission, source);
  95
  96         struct appdata *ad = (struct appdata *)data;
  97         mp_retm_if(ad == NULL, "appdata is NULL");
  98
  99         if (source)
 100
 101         {
 102                 if (strcmp(source, "rew_btn_down") == 0)
 103                 {
 104                         DEBUG_TRACE("REW");
 105                         mp_play_control_rew_cb(data, obj, "rew_btn_down", CTR_EDJ_SIG_SRC);
 106
 107                 }
 108                 else if (strcmp(source, "rew_btn_up") == 0)
 109                 {
 110                         DEBUG_TRACE("REW_up");
 111                         mp_play_control_rew_cb(data, obj, "rew_btn_up", CTR_EDJ_SIG_SRC);
 112
 113
 114                 }
 115                 else if (strcmp(source, "play") == 0)
 116                 {
 117
 118                         if (ad->minicon_timer)  //Destroy the Hide out Timer.
 119                         {
 120                                 ecore_timer_del(ad->minicon_timer);
 121                                 ad->minicon_timer = NULL;
 122                         }
 123                         if (ad->player_state == PLAY_STATE_PLAYING)
 124                         {
 125                                 mp_play_control_play_pause(data, obj, SIGNAL_PAUSE, source);
 126                                 edje_object_signal_emit(elm_layout_edje_get(ad->minicontroller_layout), "set_pause",
 127                                                         "play.pause.image");
 128                         }
 129                         else
 130                         {
 131                                 mp_play_control_play_pause(data, obj, SIGNAL_PLAY, source);
 132                                 edje_object_signal_emit(elm_layout_edje_get(ad->minicontroller_layout), "set_play",
 133                                                         "play.pause.image");
 134
 135                         }
 136                 }
 137
 138                 else if (strcmp(source, "ff_btn_down") == 0)
 139                 {
 140                         DEBUG_TRACE("FWD_down");
 141                         mp_play_control_ff_cb(data, obj, "ff_btn_down", CTR_EDJ_SIG_SRC);
 142
 143                 }
 144                 else if (strcmp(source, "ff_btn_up") == 0)
 145                 {
 146                         DEBUG_TRACE("FWD_up");
 147                         mp_play_control_ff_cb(data, obj, "ff_btn_up", CTR_EDJ_SIG_SRC);
 148
 149
 150                 }
 151                 else if (!g_strcmp0(source, "repeat"))
 152                 {
 153                         DEBUG_TRACE("REPEAT");
 154                         int repeat_state = 0;
 155                         mp_setting_get_repeat_state(&repeat_state);
 156                         repeat_state++;
 157                         repeat_state %= 3;
 158                         ad->play_rep_state = repeat_state;
 159                         mp_setting_set_repeat_state(repeat_state);
 160                         mp_play_control_repeat_set(ad, repeat_state);
 161                 }
 162                 else if (!g_strcmp0(source, "shuffle"))
 163                 {
 164                         DEBUG_TRACE("SHUFFLE");
 165                         int shuffle_state = 0;
 166                         mp_setting_get_shuffle_state(&shuffle_state);
 167                         shuffle_state = !shuffle_state;
 168                         ad->play_shuffle_state = shuffle_state;
 169                         mp_setting_set_shuffle_state(shuffle_state);
 170                         mp_play_control_shuffle_set(ad, shuffle_state);
 171                 }
 172                 else if (strcmp(source, "albumart") == 0)
 173                 {
 174                         //mp_minicontroller_destroy(ad);
 175                         DEBUG_TRACE("albumart");
 176                         ad->load_play_view = true;
 177                         elm_win_activate(ad->win_main);
 178                         return;
 179                 }
 180                 mp_minicontroller_update(ad);
 181
 182         }
 183
 184
 185
 186 }
 187
 188 static Evas_Object *
 189 _load_edj(Evas_Object * parent, const char *file, const char *group)
 190 {
 191         Evas_Object *eo;
 192         int r;
 193
 194         eo = elm_layout_add(parent);
 195         if (eo)
 196         {
 197                 r = elm_layout_file_set(eo, file, group);
 198                 if (!r)
 199                 {
 200                         evas_object_del(eo);
 201                         return NULL;
 202                 }
 203                 evas_object_size_hint_weight_set(eo, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 204                 elm_win_resize_object_add(parent, eo);
 205                 evas_object_show(eo);
 206         }
 207
 208         return eo;
 209 }
 210
 211 static Evas_Object *
 212 _create_bgimg(Evas_Object * parent)
 213 {
 214         Evas_Object *bg;
 215
 216         mp_retvm_if(parent == NULL, NULL, "parent is NULL");
 217
 218         DEBUG_TRACE_FUNC();
 219
 220         bg = elm_bg_add(parent);
 221         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 222         elm_win_resize_object_add(parent, bg);
 223         evas_object_color_set(bg, 37, 37, 37, 255);
 224         evas_object_show(bg);
 225
 226         return bg;
 227 }
 228
 229 static Evas_Object *
 230 _load_minicontroller(struct appdata *ad)
 231 {
 232         DEBUG_TRACE_FUNC();
 233         mp_retvm_if(ad == NULL, NULL, "appdata is NULL");
 234         Evas_Object *win = NULL;
 235         Evas_Object *eo = NULL;
 236         Evas_Object *icon = NULL;
 237
 238         win = minicontrol_win_add("musicplayer-mini");
 239         if (!win)
 240                 return NULL;
 241
 242         double scale = elm_config_scale_get();
 243         evas_object_resize(win, MINI_CONTROLLER_WIDTH * scale, MINI_CONTROLLER_HEIGHT * scale);
 244
 245         _create_bgimg(win);
 246         ad->win_minicon = win;
 247
 248         /* load edje */
 249         eo = _load_edj(win, MINICON_EDJ_NAME, "music-minicontroller");
 250         if (!eo)
 251                 return NULL;
 252
 253         icon = elm_icon_add(eo);
 254         ad->minicon_icon = icon;
 255         edje_object_signal_callback_add(_EDJ(eo), "clicked", "*", _minicontroller_action_cb, ad);
 256
 257         evas_object_show(win);
 258         //evas_object_show(eo);
 259
 260         return eo;
 261 }
 262
 263 int
 264 mp_minicontroller_create(struct appdata *ad)
 265 {
 266         DEBUG_TRACE_FUNC();
 267         mp_retvm_if(ad == NULL, -1, "appdata is NULL");
 268
 269         if (!(ad->minicontroller_layout && ad->win_minicon))
 270         {
 271                 ad->minicontroller_layout = _load_minicontroller(ad);
 272                 if (ad->minicontroller_layout == NULL)
 273                 {
 274                         DEBUG_TRACE("ERROR");
 275                         return -1;
 276                 }
 277         }
 278
 279
 280         mp_minicontroller_show(ad);
 281         return 0;
 282 }
 283
 284
 285 int
 286 mp_minicontroller_show(struct appdata *ad)
 287 {
 288         DEBUG_TRACE("minicontroller view show!!");
 289         mp_retvm_if(ad == NULL, -1, "appdata is NULL");
 290
 291         ad->b_minicontroller_show = TRUE;
 292         mp_minicontroller_update(ad);
 293         evas_object_show(ad->win_minicon);
 294         return 0;
 295
 296 }
 297
 298 void
 299 mp_minicontroller_update(struct appdata *ad)
 300 {
 301
 302         DEBUG_TRACE();
 303         mp_retm_if(ad == NULL, "appdata is NULL");
 304
 305         if (ad->player_state == PLAY_STATE_PLAYING)
 306         {
 307                 edje_object_signal_emit(elm_layout_edje_get(ad->minicontroller_layout), "set_pause", "play.pause.image");
 308
 309                 if (ad->minicon_visible)
 310                         _minicontroller_progress_timer_add(ad);
 311         }
 312         else
 313         {
 314                 edje_object_signal_emit(elm_layout_edje_get(ad->minicontroller_layout), "set_play",
 315                                         "play.pause.image");
 316         }
 317
 318         if (ad->playing_list) {
 319                 music_list_item *current_item = mp_play_list_get_current_item(ad->playing_list);
 320                 MP_CHECK(current_item);
 321                 DEBUG_TRACE("album art is %s", current_item->albumart);
 322                 if (strlen(current_item->album) > 0 && mp_util_is_image_valid(ad->evas, current_item->albumart))
 323                         elm_icon_file_set(ad->minicon_icon, current_item->albumart, NULL);
 324                 else
 325                         elm_icon_file_set(ad->minicon_icon, DEFAULT_THUMBNAIL, NULL);
 326                 edje_object_part_swallow(_EDJ(ad->minicontroller_layout), "albumart_image", ad->minicon_icon);
 327                 edje_object_part_text_set(_EDJ(ad->minicontroller_layout), "elm.text", current_item->title);
 328                 edje_object_part_text_set(_EDJ(ad->minicontroller_layout), "elm.text.2", current_item->artist);
 329
 330                 if (!ad->minicon_progress_timer)
 331                         _mp_minicontroller_update_elapsed_time(ad);
 332
 333                 const char *signal = NULL;
 334                 /* repeat state */
 335                 int repeat_state = 0;
 336                 mp_setting_get_repeat_state(&repeat_state);
 337                 if (repeat_state == MP_SETTING_REP_ALL)
 338                         signal = "set_repeat_all";
 339                 else if (repeat_state == MP_SETTING_REP_1)
 340                         signal = "set_repeat_one";
 341                 else
 342                         signal = "set_repeat_none";
 343                 edje_object_signal_emit(_EDJ(ad->minicontroller_layout), signal, "c_source");
 344
 345                 /* shuffle state */
 346                 int shuffle_state = false;
 347                 mp_setting_get_shuffle_state(&shuffle_state);
 348                 if (shuffle_state)
 349                         signal = "set_shuffle_on";
 350                 else
 351                         signal = "set_shuffle_off";
 352                 edje_object_signal_emit(_EDJ(ad->minicontroller_layout), signal, "c_source");
 353
 354                 evas_object_show(ad->minicontroller_layout);
 355         }
 356 }
 357
 358 int
 359 mp_minicontroller_hide(struct appdata *ad)
 360 {
 361         DEBUG_TRACE("minicontroller view hide!!\n");
 362         mp_retvm_if(ad == NULL, -1, "appdata is NULL");
 363
 364         evas_object_hide(ad->win_minicon);
 365         ad->b_minicontroller_show = FALSE;
 366
 367         if (ad->minicon_timer)
 368         {
 369                 ecore_timer_del(ad->minicon_timer);
 370                 ad->minicon_timer = NULL;
 371         }
 372
 373         if (ad->minicon_progress_timer)
 374         {
 375                 ecore_timer_del(ad->minicon_progress_timer);
 376                 ad->minicon_progress_timer = NULL;
 377         }
 378
 379         return 0;
 380
 381 }
 382
 383 int
 384 mp_minicontroller_destroy(struct appdata *ad)
 385 {
 386         DEBUG_TRACE("minicontroller view destroy!!");
 387         mp_retvm_if(ad == NULL, -1, "appdata is NULL");
 388
 389         if (ad->minicontroller_layout != NULL)
 390         {
 391                 evas_object_hide(ad->minicontroller_layout);
 392                 evas_object_del(ad->minicontroller_layout);
 393                 ad->minicontroller_layout = NULL;
 394                 ad->b_minicontroller_show = FALSE;
 395         }
 396
 397         if (ad->win_minicon)
 398         {
 399                 evas_object_del(ad->win_minicon);
 400                 ad->win_minicon = NULL;
 401         }
 402
 403         ad->minicon_visible = false;
 404
 405         return 0;
 406 }
 407
 408 void
 409 mp_minicontroller_rotate(struct appdata *ad, int angle)
 410 {
 411         MP_CHECK(ad);
 412
 413         int w = 0;
 414         const char *signal = NULL;
 415         if (angle == 90 || angle == 270) {
 416                 signal = "sig_set_landscape_mode";
 417                 w = MINI_CONTROLLER_WIDTH_LANDSCAPE;
 418         } else {
 419                 signal = "sig_set_portrait_mode";
 420                 w = MINI_CONTROLLER_WIDTH;
 421         }
 422
 423         edje_object_signal_emit(_EDJ(ad->minicontroller_layout), signal, "c_source");
 424
 425         double scale = elm_scale_get();
 426         evas_object_resize(ad->win_minicon, w * scale, MINI_CONTROLLER_HEIGHT * scale);
 427         elm_win_rotation_with_resize_set(ad->win_minicon, angle);
 428 }
 429
 430 void
 431 mp_minicontroller_visible_set(struct appdata *ad, bool visible)
 432 {
 433         MP_CHECK(ad);
 434
 435         ad->minicon_visible = visible;
 436         if (visible)
 437         {
 438                 _minicontroller_progress_timer_add(ad);
 439
 440         }
 441         else
 442         {
 443                 mp_ecore_timer_del(ad->minicon_progress_timer);
 444         }
 445 }
 446