src/standards/Tizen/Mediacontent/MediacontentController.cpp

   1 /*
   2 * Copyright (c) 2011 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
  18
  19 #include <dpl/log/log.h>
  20 #include <CommonsJavaScript/JSCallbackManager.h>
  21 #include <Tizen/Common/JSTizenException.h>
  22 #include <Tizen/Common/JSTizenExceptionFactory.h>
  23 #include "MediacontentController.h"
  24 #include "MediaConverter.h"
  25 #include "JSMediacontent.h"
  26 #include "MediaContentAsyncCallbackManager.h"
  27
  28
  29 namespace TizenApis {
  30 namespace Tizen1_0 {
  31 namespace Mediacontent {
  32
  33 MediacontentManagerController& MediacontentManagerController::getInstance()
  34 {
  35     static MediacontentManagerController instance;
  36     return instance;
  37 }
  38
  39 MediacontentManagerController::MediacontentManagerController():
  40         //EventFindMediaAnswerReceiver(ThreadEnum::NULL_THREAD),
  41         EventBrowseFolderAnswerReceiver(ThreadEnum::NULL_THREAD),
  42         EventUpdateMediaItemsAnswerReceiver(ThreadEnum::NULL_THREAD),
  43         EventFindFolderAnswerReceiver(ThreadEnum::NULL_THREAD)
  44 {
  45         LogDebug("create a MediacontentManagerController");
  46 }
  47
  48 MediacontentManagerController::~MediacontentManagerController()
  49 {
  50         LogDebug("<<<");
  51         LogDebug(">>>");
  52 }
  53
  54
  55 void MediacontentManagerController::OnAnswerReceived(const IEventUpdateMediaItemsPtr &event)
  56 {
  57
  58         LogDebug("MediacontentManagerController::IEventUpdateMediaItemsPtr:entered");
  59
  60     JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  61     if(!cbm)
  62         {
  63         LogError("no callback manager");
  64         return;
  65     }
  66     Try
  67     {
  68         MediaContentAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
  69         if (event->getResult())
  70                 {
  71                         cbm->callOnSuccess();
  72         }
  73         else
  74         {
  75                         JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
  76                                         cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
  77                         cbm->callOnError(errorObject);
  78         }
  79         return;
  80     }
  81     Catch(Exception)
  82     {
  83         LogError("error during processing answer");
  84     }
  85 }
  86
  87
  88 void MediacontentManagerController::OnAnswerReceived(const IEventBrowseFolderPtr &event)
  89 {
  90
  91         LogDebug("MediacontentManagerController::OnAnswerReceived:entered");
  92
  93     JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
  94     if (!cbm)
  95         {
  96         LogError("no callback manager");
  97         return;
  98     }
  99     Try
 100     {
 101         MediaContentAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
 102         if (event->getResult())
 103                 {
 104             MediaConverterFactory::ConverterType converter = MediaConverterFactory::getConverter(cbm->getContext());
 105             const std::vector<MediacontentMediaPtr> &results = event->getMedia();
 106             JSValueRef result = converter->toJSValueRef(results);
 107             cbm->callOnSuccess(result);
 108         }
 109         else
 110         {
 111                         JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 112                                         cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 113                         cbm->callOnError(errorObject);
 114         }
 115                 return;
 116     }
 117     Catch(Exception)
 118     {
 119         LogError("error during processing answer");
 120     }
 121 }
 122
 123
 124
 125 void MediacontentManagerController::OnAnswerReceived(const IEventFindFolderPtr &event)
 126 {
 127
 128         LogDebug("MediacontentManagerController::OnAnswerReceived:entered");
 129
 130     JSCallbackManagerPtr cbm = DPL::StaticPointerCast<JSCallbackManager>(event->getPrivateData());
 131     if (!cbm)
 132         {
 133         LogError("no callback manager");
 134         return;
 135     }
 136     Try
 137     {
 138         MediaContentAsyncCallbackManagerSingleton::Instance().unregisterCallbackManager(cbm);
 139         if (event->getResult())
 140                 {
 141             MediaConverterFactory::ConverterType converter = MediaConverterFactory::getConverter(cbm->getContext());
 142             const std::vector<MediacontentFolderPtr> &results = event->getFolder();
 143             JSValueRef result = converter->toJSValueRef(results);
 144             cbm->callOnSuccess(result);
 145         }
 146         else
 147         {
 148                         JSValueRef errorObject = TizenApis::Commons::JSTizenExceptionFactory::makeErrorObject(
 149                                         cbm->getContext(), TizenApis::Commons::JSTizenException::UNKNOWN_ERROR);
 150                         cbm->callOnError(errorObject);
 151         }
 152                 return;
 153     }
 154     Catch(Exception)
 155     {
 156         LogError("error during processing answer");
 157     }
 158
 159 }
 160
 161
 162 }
 163 }
 164 }
 165