src/MpAlbumContentListForm.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (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://floralicense.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  * @file                MpAlbumContentListForm.cpp
  19  * @brief               This is the implementation file for AlbumContentListForm class.
  20  */
  21
  22 #include <FSocial.h>
  23 #include "MpAlbumContentListForm.h"
  24 #include "MpAlbumListPresentationModel.h"
  25 #include "MpPlaylistPickerPopup.h"
  26 #include "MpSharePopup.h"
  27 #include "MpThumbnailInfo.h"
  28
  29 using namespace Tizen::App;
  30 using namespace Tizen::Base;
  31 using namespace Tizen::Base::Collection;
  32 using namespace Tizen::Content;
  33 using namespace Tizen::Graphics;
  34 using namespace Tizen::Io;
  35 using namespace Tizen::Social;
  36 using namespace Tizen::Ui;
  37 using namespace Tizen::Ui::Controls;
  38 using namespace Tizen::Ui::Scenes;
  39
  40 AlbumContentListForm::AlbumContentListForm(void)
  41         : ContentListForm::ContentListForm()
  42         , ThumbnailBase::ThumbnailBase()
  43         , __pContentListTableView(null)
  44         , __pThumbnail(null)
  45         , __pPresentationModel(null)
  46         , __checkedItemCount(0)
  47         , __currentAlbumIndex(-1)
  48         , __activatedStateContextItem(-1)
  49 {
  50         AppLogDebug("ENTER");
  51         AppLogDebug("EXIT");
  52 }
  53
  54 AlbumContentListForm::~AlbumContentListForm(void)
  55 {
  56         AppLogDebug("ENTER");
  57         AppLogDebug("EXIT");
  58 }
  59
  60 result
  61 AlbumContentListForm::Initialize(void)
  62 {
  63         AppLogDebug("ENTER");
  64         if (IsFailed(Form::Construct(IDL_CONTENT_LIST_FORM)))
  65         {
  66                 AppLogDebug("Construct(IDL_CONTENT_LIST_FORM) failed(%s)", GetErrorMessage(GetLastResult()));
  67                 return false;
  68         }
  69
  70         AppLogDebug("EXIT");
  71         return Construct();
  72 }
  73
  74 result
  75 AlbumContentListForm::Construct(void)
  76 {
  77         AppLogDebug("ENTER");
  78         __pContentListTableView = static_cast<TableView*>(GetControl(IDC_TABLEVIEW_CONTENT_LIST));
  79         __pContentListTableView->AddTableViewItemEventListener(*this);
  80         __pContentListTableView->SetItemProvider(this);
  81
  82         SetContentList(__pContentListTableView);
  83         AppLogDebug("EXIT");
  84         return ContentListForm::Construct();
  85 }
  86
  87 result
  88 AlbumContentListForm::OnInitializing(void)
  89 {
  90         AppLogDebug("ENTER");
  91         __fontSizeValue = CommonUtil::GetFontSizeValue();
  92         __itemHeight = CommonUtil::GetItemHeight(__fontSizeValue);
  93
  94         AppLogDebug("EXIT");
  95         return ThumbnailBase::Construct();
  96 }
  97
  98 result
  99 AlbumContentListForm::OnTerminating(void)
 100 {
 101         AppLogDebug("ENTER");
 102         ThumbnailBase::Stop();
 103         AppLogDebug("EXIT");
 104         return ContentListForm::OnTerminating();
 105 }
 106
 107 void
 108 AlbumContentListForm::OnActionPerformed(const Tizen::Ui::Control& source, int actionId)
 109 {
 110         AppLogDebug("ENTER");
 111         SceneManager* pSceneManager = SceneManager::GetInstance();
 112         AppAssert(pSceneManager);
 113
 114         switch (actionId)
 115         {
 116         case IDA_HEADER_BUTTON_SELECTE_ALL:
 117                 {
 118                         bool isChecked = true;
 119                         if (__checkedItemCount == __pContentListTableView->GetItemCount())
 120                         {
 121                                 isChecked = false;
 122                         }
 123                         SetItemCheckedAll(isChecked);
 124                 }
 125                 break;
 126
 127         case IDA_FOOTER_BUTTON_SHARE:
 128                 {
 129                         LanucherPicker(PICKER_TYPE_SHARE_PICKER);
 130                 }
 131                 break;
 132
 133         case IDA_FOOTER_BUTTON_ADD_TO_PLAYLIST:
 134                 {
 135                         LanucherPicker(PICKER_TYPE_PLAY_LIST_PICKER);
 136                 }
 137                 break;
 138
 139         case IDA_FOOTER_BUTTON_MORE:
 140                 {
 141                         Point anchorPoint(X_POINT_FOOTER_MORE, Y_POINT_PORTRAIT_FOOTER_MORE);
 142                         if ((GetOrientationStatus() == ORIENTATION_STATUS_LANDSCAPE) || (GetOrientationStatus() == ORIENTATION_STATUS_LANDSCAPE_REVERSE))
 143                         {
 144                                 anchorPoint.y = Y_POINT_LANDSCAPE_FOOTER_MORE;
 145                         }
 146
 147                         CreateOptionMenuN(source);
 148                         SetOptionMenuItem(CONTEXT_MENU_ITEM_STYLE_SHARE_VIA | CONTEXT_MENU_ITEM_STYLE_EDIT);
 149                 }
 150                 break;
 151
 152         case IDA_CONTEXT_MENU_ITEM_SHARE_VIA:
 153                 {
 154                         ToggleScreenState(SCREEN_STATE_SHARE_VIA);
 155                 }
 156                 break;
 157
 158         case IDA_CONTEXT_MENU_ITEM_EDIT:
 159                 {
 160                         ToggleScreenState(SCREEN_STATE_EDITOR);
 161                 }
 162                 break;
 163
 164         case IDA_CONTEXT_MENU_ITEM_SEARCH:
 165                 {
 166                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SEARCH, SCENE_TRANSITION_ANIMATION_TYPE_NONE, SCENE_HISTORY_OPTION_NO_HISTORY));
 167                 }
 168                 break;
 169
 170         case IDA_FOOTER_BUTTON_DELETE:
 171                 {
 172                         RemoveCheckedTableviewItem(true);
 173                 }
 174                 break;
 175
 176         default:
 177                 break;
 178         }
 179
 180         TryRemoveContextMenu(actionId);
 181         AppLogDebug("EXIT");
 182 }
 183
 184 void
 185 AlbumContentListForm::OnFormMenuRequested(Tizen::Ui::Controls::Form& source)
 186 {
 187         if (GetScreenState() == SCREEN_STATE_NORMAL && IsEmptyContentList() == false)
 188         {
 189                 CreateOptionMenuN(source);
 190                 SetOptionMenuItem(CONTEXT_MENU_ITEM_STYLE_SHARE_VIA | CONTEXT_MENU_ITEM_STYLE_EDIT);
 191         }
 192 }
 193 void
 194 AlbumContentListForm::OnSceneActivatedN(const Tizen::Ui::Scenes::SceneId& previousSceneId,
 195                                         const Tizen::Ui::Scenes::SceneId& currentSceneId,
 196                                         Tizen::Base::Collection::IList* pArgs)
 197 {
 198         AppLogDebug("ENTER");
 199         if (pArgs != null)
 200         {
 201                 __prevSceneId.Clear();
 202                 __prevSceneId.Append(*static_cast<String*>(pArgs->GetAt(DATA_ITEM_SCENE_NAME)));
 203                 __pPresentationModel = AlbumListPresentationModel::GetInstance();
 204
 205                 if (__prevSceneId.Equals(IDSCN_SEARCH, false))
 206                 {
 207                         __pPresentationModel->UpdateAlbumList();
 208                         __ablumName = *(static_cast<String*>(pArgs->GetAt(DATA_ITEM_CONTENT_NAME)));
 209                         __currentAlbumIndex = __pPresentationModel->searchAlbumIndex(__ablumName);
 210                 }
 211                 else if (previousSceneId.Equals(IDSCN_PLAYLIST_CREATOR, false))
 212                 {
 213                         SetItemCheckedAll(false);
 214                 }
 215                 else
 216                 {
 217                         __currentAlbumIndex = static_cast<Integer*>(pArgs->GetAt(DATA_ITEM_CONTENT_TYPE))->ToInt();
 218                 }
 219
 220                 __pPresentationModel->InitializeContentList(__currentAlbumIndex);
 221                 String* pAlbumName = __pPresentationModel->GetAlbumName(__currentAlbumIndex);
 222                 if (pAlbumName != null)
 223                 {
 224                         __ablumName = *pAlbumName;
 225                         __headerTitle.Format(255, pAlbumName->GetPointer());
 226                 }
 227
 228                 ContentInformation* pContentInfo = __pPresentationModel->GetAlbumInfoN(__currentAlbumIndex);
 229                 if (pContentInfo != null)
 230                 {
 231                         Panel* pContentInfoPanel = new (std::nothrow) Panel();
 232                         pContentInfoPanel->Construct(IDL_CONTENT_LIST_ALBUM_INFO_PANEL);
 233
 234                         static_cast<Label*>(pContentInfoPanel->GetControl(IDC_CONTENTS_THUMBNAIL))->SetBackgroundBitmap(*GetDefaultThumbnail());
 235                         static_cast<Label*>(pContentInfoPanel->GetControl(IDC_CONTENTS_TITLE_NAME))->SetText(pContentInfo->AlbumName);
 236                         static_cast<Label*>(pContentInfoPanel->GetControl(IDC_CONTENTS_ARTIST_NAME))->SetText(pContentInfo->ArtistName);
 237                         static_cast<Label*>(pContentInfoPanel->GetControl(IDC_PLAY_CONTENT_COUNT))->SetText(CommonUtil::SetSongsString(__pPresentationModel->GetContentCount(__currentAlbumIndex)));
 238
 239                         Bitmap* pBgBitmap = ResourceManager::GetBitmapN(L"T02_album_bg.png");
 240                         Label* pBgLabel = static_cast<Label*>(pContentInfoPanel->GetControl(IDC_LABEL_ALBUM_BACKGROUND));
 241                         pBgLabel->SetBackgroundBitmap(*pBgBitmap);
 242                         pContentInfoPanel->SetControlAlwaysAtBottom(*pBgLabel, true);
 243                         delete pBgBitmap;
 244
 245                         SetExtraInformaionArea(*pContentInfoPanel);
 246                         RequestThumbnail(pContentInfo->contentId);
 247                         delete pContentInfo;
 248                 }
 249
 250                 pArgs->RemoveAll(true);
 251                 delete pArgs;
 252
 253                 SetHeader();
 254                 UpdateScreenState();
 255                 UpdateTableView();
 256         }
 257         AppLogDebug("EXIT");
 258 }
 259
 260 void
 261 AlbumContentListForm::OnSceneDeactivated(const Tizen::Ui::Scenes::SceneId& currentSceneId,
 262                                                                         const Tizen::Ui::Scenes::SceneId& nextSceneId)
 263 {
 264         AppLogDebug("ENTER");
 265         CancelAllThumbnailRequest();
 266         AppLogDebug("EXIT");
 267 }
 268
 269 int
 270 AlbumContentListForm::GetItemCount(void)
 271 {
 272         AppLogDebug("ENTER");
 273         int itemCount = INIT_VALUE;
 274         String* pAlbum = __pPresentationModel->GetAlbumName(__currentAlbumIndex);
 275         if (pAlbum != null && pAlbum->Equals(__ablumName, false))
 276         {
 277                 itemCount = __pPresentationModel->GetContentCount(__currentAlbumIndex);
 278         }
 279         AppLogDebug("EXIT");
 280         return itemCount;
 281 }
 282
 283 void
 284 AlbumContentListForm::OnTableViewContextItemActivationStateChanged(Tizen::Ui::Controls::TableView& tableView, int itemIndex,
 285                                                                                 Tizen::Ui::Controls::TableViewContextItem* pContextItem,
 286                                                                                 bool activated)
 287 {
 288         AppLogDebug("ENTER");
 289         if (itemIndex >= 0)
 290         {
 291                 AppLogDebug("INDEX %d", itemIndex);
 292                 __activatedStateContextItem = itemIndex;
 293         }
 294         AppLogDebug("EXIT");
 295 }
 296
 297 int
 298 AlbumContentListForm::GetDefaultItemHeight(void)
 299 {
 300         AppLogDebug("ENTER");
 301         AppLogDebug("EXIT");
 302         return ITEM_HEIGHT;
 303 }
 304
 305 bool
 306 AlbumContentListForm::DeleteItem(const int itemIndex, Tizen::Ui::Controls::TableViewItem* pItem)
 307 {
 308         AppLogDebug("ENTER");
 309         AppLogDebug("EXIT");
 310         return false;
 311 }
 312
 313 void
 314 AlbumContentListForm::OnTableViewItemReordered(Tizen::Ui::Controls::TableView& tableView,
 315                                                         int itemIndexFrom,
 316                                                         int itemIndexTo)
 317 {
 318         AppLogDebug("ENTER");
 319         AppLogDebug("EXIT");
 320 }
 321
 322
 323 Tizen::Ui::Controls::TableViewItem*
 324 AlbumContentListForm::CreateItem(const int itemIndex, int itemWidth)
 325 {
 326         AppLogDebug("ENTER");
 327         RelativeLayout layout;
 328         layout.Construct();
 329
 330         TableViewAnnexStyle tableViewAnnexStyle = TABLE_VIEW_ANNEX_STYLE_NORMAL;
 331         if (GetScreenState() != SCREEN_STATE_NORMAL)
 332         {
 333                 tableViewAnnexStyle = TABLE_VIEW_ANNEX_STYLE_MARK;
 334         }
 335
 336         TableViewItem* pItem = new (std::nothrow) TableViewItem();
 337         ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(itemIndex);
 338
 339         result r = pItem->Construct(layout, Dimension(itemWidth, __itemHeight), tableViewAnnexStyle);
 340         TryCatch(r == E_SUCCESS, delete pItem, "pItem->Construct(%s)", GetErrorMessage(r));
 341         TryCatch(pContentInfo != null, delete pItem, "pContentInfo is null", GetErrorMessage(GetLastResult()));
 342
 343         r = CreateTableViewItem(*pItem, *pContentInfo);
 344         TryCatch(r == E_SUCCESS, delete pItem, "CreateTableViewItem failed(%s)", GetErrorMessage(r));
 345         delete pContentInfo;
 346
 347         AppLogDebug("EXIT");
 348         return pItem;
 349
 350 CATCH:
 351         AppLogDebug("EXIT(%ls)", GetErrorMessage(GetLastResult()));
 352         delete pContentInfo;
 353         return null;
 354 }
 355
 356 void
 357 AlbumContentListForm::UpdateItem(int itemIndex, Tizen::Ui::Controls::TableViewItem* pItem)
 358 {
 359         AppLogDebug("ENTER");
 360         AppLogDebug("EXIT");
 361 }
 362
 363 void
 364 AlbumContentListForm::OnTableViewItemStateChanged(Tizen::Ui::Controls::TableView& tableView,
 365                                                         int itemIndex,
 366                                                         Tizen::Ui::Controls::TableViewItem* pItem,
 367                                                         Tizen::Ui::Controls::TableViewItemStatus status)
 368 {
 369         AppLogDebug("ENTER");
 370         if (GetScreenState() != SCREEN_STATE_NORMAL)
 371         {
 372                 SetItemCheckedStateChanged(status);
 373                 AppLogDebug("EXIT");
 374                 return;
 375         }
 376
 377         if (status == TABLE_VIEW_ITEM_STATUS_SELECTED)
 378         {
 379                 SceneManager* pSceneManager = SceneManager::GetInstance();
 380                 AppAssert(pSceneManager);
 381
 382                 ArrayList* pSceneArg = MakePlayerSceneParam(itemIndex);
 383                 if (pSceneArg != null)
 384                 {
 385                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_PLAYER), pSceneArg);
 386                 }
 387         }
 388         AppLogDebug("EXIT");
 389 }
 390
 391 Tizen::Base::Collection::ArrayList*
 392 AlbumContentListForm::MakePlayerSceneParam(int startIndex)
 393 {
 394         AppLogDebug("ENTER");
 395         ArrayList* pTempList = new (std::nothrow) ArrayList();
 396         if (pTempList == null)
 397         {
 398                 AppLogDebug("EXIT");
 399                 return null;
 400         }
 401
 402         ArrayList* pSelectedMusicContent = null;
 403
 404         pSelectedMusicContent = __pPresentationModel->GetContentPathListN(__currentAlbumIndex);
 405         if (pSelectedMusicContent == null)
 406         {
 407                 delete pTempList;
 408                 AppLogDebug("EXIT");
 409                 return null;
 410         }
 411         pTempList->Construct();
 412
 413         pTempList->Add(*(new (std::nothrow) String(MUSIC)));
 414         pTempList->Add(*(new (std::nothrow) Integer(startIndex)));
 415         pTempList->Add(*(pSelectedMusicContent));
 416
 417         AppLogDebug("EXIT");
 418         return pTempList;
 419 }
 420
 421 bool
 422 AlbumContentListForm::IsEmptyContentList(void)
 423 {
 424         AppLogDebug("ENTER");
 425         String* pAlbum = __pPresentationModel->GetAlbumName(__currentAlbumIndex);
 426         if (pAlbum != null && pAlbum->Equals(__ablumName, false))
 427         {
 428                 if (__pPresentationModel->GetContentCount(__currentAlbumIndex) != INIT_VALUE)
 429                 {
 430                         return false;
 431                 }
 432         }
 433         AppLogDebug("EXIT");
 434         return true;
 435 }
 436
 437 result
 438 AlbumContentListForm::SetHeader(void)
 439 {
 440         AppLogDebug("ENTER");
 441         CommonUtil::SetSimpleTitleStyle(*GetHeader(), __headerTitle);
 442         AppLogDebug("EXIT");
 443         return E_SUCCESS;
 444 }
 445
 446 result
 447 AlbumContentListForm::CreateTableViewItem(Tizen::Ui::Controls::TableViewItem& parent, const ContentInformation& contentInfo)
 448 {
 449         AppLogDebug("ENTER");
 450         Panel* pTableViewItem =  new (std::nothrow) Panel();
 451
 452         if (GetScreenState() != SCREEN_STATE_NORMAL)
 453         {
 454                 if (__fontSizeValue.Equals(STRING_FONT_SIZE_GIANT, false))
 455                 {
 456                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_EDIT_ITEM_PANEL_FONT_SIZE_GIANT)))
 457                         {
 458                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 459                                 return E_FAILURE;
 460                         }
 461                 }
 462                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_HUGE, false))
 463                 {
 464                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_EDIT_ITEM_PANEL_FONT_SIZE_HUGE)))
 465                         {
 466                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 467                                 return E_FAILURE;
 468                         }
 469                 }
 470                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_LARGE, false))
 471                 {
 472                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_EDIT_ITEM_PANEL_FONT_SIZE_LARGE)))
 473                         {
 474                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 475                                 return E_FAILURE;
 476                         }
 477                 }
 478                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_SMALL, false))
 479                 {
 480                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_EDIT_ITEM_PANEL_FONT_SIZE_SMALL)))
 481                         {
 482                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 483                                 return E_FAILURE;
 484                         }
 485                 }
 486                 else
 487                 {
 488                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_EDIT_ITEM_PANEL_DEFAULT)))
 489                         {
 490                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 491                                 return E_FAILURE;
 492                         }
 493                 }
 494         }
 495         else
 496         {
 497                 if (__fontSizeValue.Equals(STRING_FONT_SIZE_GIANT, false))
 498                 {
 499                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_ITEM_PANEL_FONT_SIZE_GIANT)))
 500                         {
 501                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 502                                 return E_FAILURE;
 503                         }
 504                 }
 505                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_HUGE, false))
 506                 {
 507                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_ITEM_PANEL_FONT_SIZE_HUGE)))
 508                         {
 509                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 510                                 return E_FAILURE;
 511                         }
 512                 }
 513                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_LARGE, false))
 514                 {
 515                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_ITEM_PANEL_FONT_SIZE_LARGE)))
 516                         {
 517                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 518                                 return E_FAILURE;
 519                         }
 520                 }
 521                 else if (__fontSizeValue.Equals(STRING_FONT_SIZE_SMALL, false))
 522                 {
 523                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_ITEM_PANEL_FONT_SIZE_SMALL)))
 524                         {
 525                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 526                                 return E_FAILURE;
 527                         }
 528                 }
 529                 else
 530                 {
 531                         if (IsFailed(pTableViewItem->Construct(IDL_ALBUM_CONTENT_ITEM_PANEL_DEFAULT)))
 532                         {
 533                                 AppLogDebug("Construct(IDL_CONTENTS_LIBARY_ITEM_PANEL) failed(%s)", GetErrorMessage(GetLastResult()));
 534                                 return E_FAILURE;
 535                         }
 536                 }
 537         }
 538
 539         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENTS_TITLE_NAME))->SetText(contentInfo.TitleName);
 540         static_cast<Label*>(pTableViewItem->GetControl(IDC_CONTENT_TOTAL_COUNT))->SetText(CommonUtil::GetFormatDate(contentInfo.Duration));
 541
 542         parent.AddControl(pTableViewItem);
 543         parent.SetIndividualSelectionEnabled(pTableViewItem, true);
 544
 545         CommonUtil::SetLayoutFitToContainer(parent, *pTableViewItem);
 546
 547         AppLogDebug("EXIT");
 548         return E_SUCCESS;
 549 }
 550
 551 void
 552 AlbumContentListForm::OnAppControlCompleteResponseReceived(const AppId& appId,
 553                 const String& operationId, AppCtrlResult appControlResult,
 554                 const IMap* pExtraData)
 555 {
 556         AppLogDebug("ENTER");
 557         if (pExtraData == null)
 558         {
 559                 AppLogDebug("EXIT");
 560                 return;
 561         }
 562
 563         AppLogDebug("%ls, %ls", appId.GetPointer(), operationId.GetPointer());
 564         if (appId.Equals(String(PROVIDER_ID_CONTACT)))
 565         {
 566                 if (appControlResult == APP_CTRL_RESULT_SUCCEEDED)
 567                 {
 568                         const String* pResultString = static_cast<const String*>(pExtraData->GetValue(String(APPCONTROL_KEY_SOCIAL_ITEM_ID)));
 569
 570                         AppLogDebug("%ls", pResultString->GetPointer());
 571                         int contactId;
 572                         Integer::Parse(*pResultString, contactId);
 573
 574                         AddressbookManager* pAddressbookManager = AddressbookManager::GetInstance();
 575                         Addressbook* pAddressbook = pAddressbookManager->GetAddressbookN(DEFAULT_ADDRESSBOOK_ID);
 576
 577                         ContentInformation* pCcontentInfo = __pPresentationModel->GetContentInfoN(__activatedStateContextItem);
 578                         if (pCcontentInfo == null)
 579                         {
 580                                 delete pAddressbook;
 581                                 pAddressbook = null;
 582                                 return;
 583                         }
 584
 585                         Contact* pContact = pAddressbook->GetContactN(contactId);
 586                         pContact->SetValue(CONTACT_PROPERTY_ID_RINGTONE, pCcontentInfo->ContentFilePath);
 587                         result r = pAddressbook->UpdateContact(*pContact);
 588
 589                         if (r == E_SUCCESS)
 590                         {
 591                                 ShowDelayedMessageBox(ResourceManager::GetString(L"IDS_COM_POP_SUCCESS"));
 592                         }
 593
 594                         delete pCcontentInfo;
 595                         pCcontentInfo = null;
 596
 597                         delete pContact;
 598                         pContact = null;
 599
 600                         delete pAddressbook;
 601                         pAddressbook = null;
 602                 }
 603         }
 604         AppLogDebug("EXIT");
 605 }
 606
 607 void
 608 AlbumContentListForm::OnThumbnailInfoReveivedN(ThumbnailInfo* pThumbnailInfo)
 609 {
 610         AppLogDebug("ENTER");
 611         Panel* pItemPanel = static_cast<Panel*>(GetExtraInformaionAreaControl());
 612
 613         if (pItemPanel == null)
 614         {
 615                 AppLogDebug("pItemPanel is null");
 616                 return;
 617         }
 618
 619         Label* pThumbnailLabel = static_cast<Label*>(pItemPanel->GetControl(IDC_CONTENTS_THUMBNAIL));
 620         __pThumbnail = pThumbnailInfo->GetBitmapN();
 621         delete pThumbnailInfo;
 622
 623         if (__pThumbnail == null || pThumbnailLabel == null)
 624         {
 625                 if ( __pThumbnail != null)
 626                 {
 627                         AppLogDebug("pThumbnailLabel is null");
 628                 }
 629                 else
 630                 {
 631                         AppLogDebug("__pThumbnail or pThumbnailLabel is null");
 632                 }
 633
 634                 delete __pThumbnail;
 635                 __pThumbnail = null;
 636                 return;
 637         }
 638         pThumbnailLabel->SetBackgroundBitmap(*__pThumbnail);
 639         delete __pThumbnail;
 640         __pThumbnail = null;
 641
 642         pThumbnailLabel->Invalidate(true);
 643         AppLogDebug("EXIT");
 644 }
 645
 646 void
 647 AlbumContentListForm::OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs)
 648 {
 649         AppLogDebug("ENTER");
 650         ContentListForm::OnUserEventReceivedN(requestId, pArgs);
 651         AppLogDebug("EXIT");
 652 }
 653
 654 void
 655 AlbumContentListForm::OnMusicContentUpdateCompleted(void)
 656 {
 657         AppLogDebug("ENTER");
 658         ContentListForm::OnMusicContentUpdateCompleted();
 659         UpdateExtraInformaionArea();
 660         AppLogDebug("EXIT");
 661 }
 662
 663 void
 664 AlbumContentListForm::UpdateExtraInformaionArea(void)
 665 {
 666         AppLogDebug("ENTER");
 667         String albumCount;
 668         Panel* pItemPanel = static_cast<Panel*>(GetExtraInformaionAreaControl());
 669
 670         if (pItemPanel == null)
 671         {
 672                 AppLogDebug("pItemPanel is null");
 673                 return;
 674         }
 675
 676         albumCount.Format(255, L"%d songs", __pPresentationModel->GetContentCount(__currentAlbumIndex));
 677         Label* pAlbumCount = static_cast<Label*>(pItemPanel->GetControl(IDC_PLAY_CONTENT_COUNT));
 678         pAlbumCount->SetText(albumCount);
 679
 680         pAlbumCount->Invalidate(true);
 681         AppLogDebug("EXIT");
 682 }
 683
 684 void
 685 AlbumContentListForm::RemoveCheckedTableviewItem(bool itemRemove)
 686 {
 687         AppLogDebug("ENTER");
 688         if (itemRemove)
 689         {
 690                 int totalCount = __pContentListTableView->GetItemCount();
 691                 for (int iCount = 0; iCount < totalCount; iCount++)
 692                 {
 693                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 694                         {
 695                                 __pContentListTableView->SetItemChecked(iCount, false);
 696                                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(iCount);
 697                                 RemoveContentAt(pContentInfo->contentId);
 698                                 delete pContentInfo;
 699                         }
 700                 }
 701 //              __pPresentationModel->RefreshContentList(__currentAlbumIndex);
 702         }
 703         else
 704         {
 705                 SetItemCheckedAll(false);
 706         }
 707         AppLogDebug("EXIT");
 708 }
 709
 710 void
 711 AlbumContentListForm::UpdateTableView(void)
 712 {
 713         AppLogDebug("ENTER");
 714         __pContentListTableView->UpdateTableView();
 715         AppLogDebug("EXIT");
 716 }
 717
 718 void
 719 AlbumContentListForm::UpdateContentList(void)
 720 {
 721         AppLogDebug("ENTER");
 722         bool goback = true;
 723         if (__pPresentationModel->GetContentCount(__currentAlbumIndex) > 0)
 724         {
 725                 String* pAlbum = __pPresentationModel->GetAlbumName(__currentAlbumIndex);
 726                 if (pAlbum != null && pAlbum->Equals(__ablumName, false))
 727                 {
 728                         __pPresentationModel->InitializeContentList(__currentAlbumIndex);
 729                         goback = false;
 730                         if (__prevSceneId.Equals(IDSCN_SEARCH, false) && __pPresentationModel->GetContentCount(__currentAlbumIndex) == 0)
 731                         {
 732                                 goback = true;
 733                         }
 734                 }
 735         }
 736         if (goback)
 737         {
 738                 SceneManager* pSceneManager = SceneManager::GetInstance();
 739                 AppAssert(pSceneManager);
 740                 SetScreenState(SCREEN_STATE_NORMAL);
 741                 pSceneManager->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_NONE,SCENE_DESTROY_OPTION_KEEP));
 742         }
 743
 744         AppLogDebug("EXIT");
 745 }
 746
 747 void
 748 AlbumContentListForm::SetItemCheckedAll(bool isChecked)
 749 {
 750         AppLogDebug("ENTER");
 751         if (isChecked == true)
 752         {
 753                 __checkedItemCount =  __pContentListTableView->GetItemCount();
 754         }
 755         else
 756         {
 757                 __checkedItemCount = INIT_VALUE;
 758         }
 759         CommonUtil::SetItemCheckedAll(isChecked, *__pContentListTableView);
 760
 761         if (GetFooter() != null)
 762         {
 763                 CommonUtil::SetFooterItemEnabled(*GetFooter(), isChecked);
 764         }
 765
 766         SetCheckedCountBallonTooltip(GetCheckedItemCount());
 767         AppLogDebug("EXIT");
 768 }
 769
 770 void
 771 AlbumContentListForm::SetItemCheckedStateChanged(Tizen::Ui::Controls::TableViewItemStatus status)
 772 {
 773         AppLogDebug("ENTER");
 774         if (status == TABLE_VIEW_ITEM_STATUS_UNCHECKED)
 775         {
 776                 __checkedItemCount--;
 777                 if (__checkedItemCount == INIT_VALUE)
 778                 {
 779                         if (GetFooter() != null)
 780                         {
 781                                 CommonUtil::SetFooterItemEnabled(*GetFooter(), false);
 782                         }
 783                 }
 784         }
 785         else if (status == TABLE_VIEW_ITEM_STATUS_CHECKED)
 786         {
 787                 if (__checkedItemCount == INIT_VALUE)
 788                 {
 789                         if (GetFooter() != null)
 790                         {
 791                                 CommonUtil::SetFooterItemEnabled(*GetFooter(), true);
 792                         }
 793                 }
 794
 795                 __checkedItemCount++;
 796         }
 797
 798         SetCheckedCountBallonTooltip(GetCheckedItemCount());
 799         AppLogDebug("EXIT");
 800 }
 801
 802 int
 803 AlbumContentListForm::GetCheckedItemCount(void)
 804 {
 805         AppLogDebug("ENTER");
 806         AppLogDebug("EXIT");
 807         return __checkedItemCount;
 808 }
 809
 810 Tizen::Base::Collection::IList*
 811 AlbumContentListForm::GetPickerArgumentListN(PickerType pickerType, PickerArgumentType argumentType)
 812 {
 813         AppLogDebug("ENTER");
 814         Tizen::Base::Collection::ArrayList* pContentFilePathList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 815         if (IsFailed(pContentFilePathList->Construct()))
 816         {
 817                 AppLogDebug("pContentList->Construct failed(%s)", GetErrorMessage(GetLastResult()));
 818                 delete pContentFilePathList;
 819                 return null;
 820         }
 821
 822         if (argumentType == PICKER_ARGUMENT_TYPE_ACTIVATED_STATE_CONTEXT_ITEM)
 823         {
 824                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(__activatedStateContextItem);
 825                 if (pContentInfo == null)
 826                 {
 827                         delete pContentFilePathList;
 828                         AppLogDebug("GetContentInfoN(%d) is null", __activatedStateContextItem);
 829                         return null;
 830                 }
 831
 832                 pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 833                 delete pContentInfo;
 834         }
 835         else if (argumentType == PICKER_ARGUMENT_TYPE_CHECKED_ITEM_ALL)
 836         {
 837                 int totalCount = __pContentListTableView->GetItemCount();
 838                 for (int iCount = 0; iCount < totalCount; iCount++)
 839                 {
 840                         if (__pContentListTableView->IsItemChecked(iCount) == true)
 841                         {
 842                                 ContentInformation* pContentInfo = __pPresentationModel->GetContentInfoN(iCount);
 843                                 if (pContentInfo == null)
 844                                 {
 845                                         AppLogDebug("GetContentInfoN(%d) is null", iCount);
 846                                         delete pContentFilePathList;
 847                                         return null;
 848                                 }
 849
 850                                 if (pickerType == PICKER_TYPE_PLAY_LIST_PICKER)
 851                                 {
 852                                         pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 853                                 }
 854                                 else if (pickerType == PICKER_TYPE_SHARE_PICKER)
 855                                 {
 856                                         pContentFilePathList->Add(*(new (std::nothrow) String(pContentInfo->ContentFilePath)));
 857                                 }
 858                                 delete pContentInfo;
 859                         }
 860                 }
 861         }
 862         AppLogDebug("EXIT");
 863         return pContentFilePathList;
 864 }
 865
 866 void
 867 AlbumContentListForm::OnFontSizeChanged(void)
 868 {
 869         __fontSizeValue = CommonUtil::GetFontSizeValue();
 870         __itemHeight = CommonUtil::GetItemHeight(__fontSizeValue);
 871
 872         __pContentListTableView->UpdateTableView();
 873 }