src/wrt-installer/installer_callbacks_translate.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  * @file    api_callbacks_translate.h
  18  * @author  Pawel Sikorski (p.sikorski@samsung.com)
  19  * @version 1.0
  20  * @brief   Source file for api callbacks translate functions
  21  */
  22
  23 #include <installer_callbacks_translate.h>
  24 #include <dpl/log/log.h>
  25
  26 namespace InstallerCallbacksTranslate {
  27 WrtErrStatus TranslateError(CommonError::Type status)
  28 {
  29     switch (status) {
  30     case CommonError::WrtSuccess:
  31         return WRT_SUCCESS;
  32
  33     case CommonError::HandleNotFound:
  34         return WRT_ERROR_HANDLE_NOT_FOUND;
  35
  36     case CommonError::AlreadyRunning:
  37         return WRT_ERROR_ALREADY_RUNNING;
  38
  39     case CommonError::InvalidLanguage:
  40         return WRT_ERROR_INVALID_LANGUAGE;
  41
  42     case CommonError::AlreadyStopped:
  43         return WRT_ERROR_ALREADY_STOPPED;
  44
  45     case CommonError::StillAuthorizing:
  46         return WRT_ERROR_STILL_AUTHORIZING;
  47
  48     case CommonError::EarlyKilled:
  49         return WRT_ERROR_EARLY_KILLED;
  50
  51     case CommonError::AccessDenied:
  52         return WRT_ERROR_ACCESS_DENIED;
  53
  54     default:
  55         LogError("Untranslatable error: " << status);
  56         return WRT_ERROR_INTERNAL;
  57     }
  58 }
  59
  60 void StatusCallback(std::string tizenId,
  61                     CommonError::Type result,
  62                     void *data)
  63 {
  64     LogDebug("StatusCallback called  " << tizenId << " | " << result);
  65     Assert(data != NULL);
  66
  67     WrtErrStatus error = TranslateError(result);
  68     StatusCallbackStruct* statusCallbackStruct =
  69         static_cast<StatusCallbackStruct*>(data);
  70
  71     if (statusCallbackStruct->status_callback) {
  72         statusCallbackStruct->status_callback(tizenId,
  73                                               error,
  74                                               statusCallbackStruct->userdata);
  75     } else {
  76         LogInfo("StatusCallback: ignoring NULL callback pointer");
  77     }
  78
  79     delete statusCallbackStruct;
  80 }
  81
  82 // callback for finished install
  83 void installFinishedCallback(void *userParam,
  84                              std::string tizenId,
  85                              Jobs::WidgetInstall::Exceptions::Type status)
  86 {
  87     Assert(userParam != NULL);
  88
  89     StatusCallbackStruct *apiStr =
  90         static_cast<StatusCallbackStruct*>(userParam);
  91
  92     if (apiStr->status_callback) {
  93         // Translate error
  94         WrtErrStatus errorStatus;
  95
  96         switch (status) {
  97         case Jobs::WidgetInstall::Exceptions::Success:
  98             errorStatus = WRT_SUCCESS;
  99             break;
 100
 101         case Jobs::WidgetInstall::Exceptions::ErrorInvalidWidgetPackage:
 102             errorStatus = WRT_INSTALLER_ERROR_INVALID_WIDGET_PACKAGE;
 103             break;
 104
 105         case Jobs::WidgetInstall::Exceptions::ErrorWidgetDoesNotExist:
 106             errorStatus = WRT_INSTALLER_ERROR_WIDGET_DOES_NOT_EXIST;
 107             break;
 108
 109         case Jobs::WidgetInstall::Exceptions::ErrorAreadyUninstalling:
 110             errorStatus = WRT_INSTALLER_ERROR_ALREADY_UNINSTALLING;
 111             break;
 112
 113         case Jobs::WidgetInstall::Exceptions::ErrorOutOfDiskSpace:
 114             errorStatus = WRT_INSTALLER_ERROR_OUT_OUT_DISK_SPACE;
 115             break;
 116
 117         case Jobs::WidgetInstall::Exceptions::ErrorInvalidPackage:
 118             errorStatus = WRT_INSTALLER_ERROR_INVALID_CERTIFICATE;
 119             break;
 120
 121         case Jobs::WidgetInstall::Exceptions::ErrorAlreadyInstalled:
 122             errorStatus = WRT_INSTALLER_ERROR_ALREADY_INSTALLED;
 123             break;
 124
 125         case Jobs::WidgetInstall::Exceptions::ErrorInternal:
 126             errorStatus = WRT_INSTALLER_ERROR_INTERNAL;
 127             break;
 128
 129         case Jobs::WidgetInstall::Exceptions::ErrorNotAllowed:
 130             errorStatus = WRT_INSTALLER_ERROR_NOT_ALLOWED;
 131             break;
 132
 133         case Jobs::WidgetInstall::Exceptions::ErrorDeferred:
 134             errorStatus = WRT_INSTALLER_ERROR_DEFERRED;
 135             break;
 136
 137         case Jobs::WidgetInstall::Exceptions::ErrorDatabaseFailure:
 138             errorStatus = WRT_INSTALLER_ERROR_DATABASE_FAILURE;
 139             break;
 140
 141         case Jobs::WidgetInstall::Exceptions::ErrorInstallOspServcie:
 142             errorStatus = WRT_INSTALLER_ERROR_OSPSVC;
 143             break;
 144
 145         case Jobs::WidgetInstall::Exceptions::ErrorUnknown:
 146             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 147             break;
 148
 149         default:
 150             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 151             break;
 152         }
 153
 154         // Callback
 155         apiStr->status_callback(tizenId, errorStatus, apiStr->userdata);
 156     } else {
 157         LogInfo("installFinishedCallback: No callback");
 158     }
 159 }
 160
 161 // callback for finished install
 162 void uninstallFinishedCallback(void *userParam,
 163                                std::string tizenId,
 164                                Jobs::WidgetUninstall::Exceptions::Type status)
 165 {
 166     Assert(userParam != NULL);
 167
 168     StatusCallbackStruct *apiStr =
 169         static_cast<StatusCallbackStruct*>(userParam);
 170
 171     if (apiStr->status_callback) {
 172         // Translate error
 173         WrtErrStatus errorStatus;
 174
 175         switch (status) {
 176         case Jobs::WidgetUninstall::Exceptions::Success:
 177             errorStatus = WRT_SUCCESS;
 178             break;
 179
 180         case Jobs::WidgetUninstall::Exceptions::ErrorAlreadyUninstalling:
 181             errorStatus = WRT_INSTALLER_ERROR_ALREADY_UNINSTALLING;
 182             break;
 183
 184         case Jobs::WidgetUninstall::Exceptions::ErrorWidgetDoesNotExist:
 185             errorStatus = WRT_INSTALLER_ERROR_WIDGET_DOES_NOT_EXIST;
 186             break;
 187
 188         case Jobs::WidgetUninstall::Exceptions::ErrorDatabaseFailure:
 189             errorStatus = WRT_INSTALLER_ERROR_DATABASE_FAILURE;
 190             break;
 191
 192         case Jobs::WidgetUninstall::Exceptions::ErrorUninstallOspSvcFailed:
 193             errorStatus = WRT_INSTALLER_ERROR_OSPSVC;
 194             break;
 195
 196         case Jobs::WidgetUninstall::Exceptions::ErrorUnknown:
 197             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 198             break;
 199
 200         default:
 201             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 202             break;
 203         }
 204
 205         // Callback
 206         apiStr->status_callback(tizenId, errorStatus, apiStr->userdata);
 207     } else {
 208         LogInfo("uninstallFinishedCallback: No callback");
 209     }
 210 }
 211
 212 void pluginInstallFinishedCallback(void *userParam,
 213                                    Jobs::PluginInstall::Exceptions::Type status)
 214 {
 215     Assert(userParam);
 216
 217     PluginStatusCallbackStruct *apiStr =
 218         static_cast<PluginStatusCallbackStruct*>(userParam);
 219
 220     if (apiStr->statusCallback) {
 221         // Translate error
 222         WrtErrStatus errorStatus;
 223
 224         switch (status) {
 225         case Jobs::PluginInstall::Exceptions::Success:
 226             errorStatus = WRT_SUCCESS;
 227             break;
 228         case Jobs::PluginInstall::Exceptions::WrongPluginPath:
 229             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_WRONG_PATH;
 230             break;
 231         case Jobs::PluginInstall::Exceptions::MetafileError:
 232             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_METAFILE;
 233             break;
 234         case Jobs::PluginInstall::Exceptions::AlreadyInstalled:
 235             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_ALREADY_INSTALLED;
 236             break;
 237         case Jobs::PluginInstall::Exceptions::LoadingLibraryError:
 238             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_LIBRARY_ERROR;
 239             break;
 240         case Jobs::PluginInstall::Exceptions::InstallationWaiting:
 241             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_WAITING;
 242             break;
 243         default:
 244             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 245             break;
 246         }
 247
 248         apiStr->statusCallback(errorStatus, apiStr->userdata);
 249     } else {
 250         LogInfo("PluginInstallFinishedCallback: No callback");
 251     }
 252
 253     delete apiStr;
 254 }
 255
 256 // callback for progress of install OR uninstall
 257 void installProgressCallback(void *userParam,
 258                              ProgressPercent percent,
 259                              const ProgressDescription &description)
 260 {
 261     Assert(userParam != NULL);
 262
 263     StatusCallbackStruct *apiStr =
 264         static_cast<StatusCallbackStruct*>(userParam);
 265
 266     if (apiStr->progress_callback) {
 267         //CALLBACK EXEC
 268         LogInfo("Entered " << percent << "% " << description);
 269         apiStr->progress_callback(static_cast<float>(percent),
 270                                   description.c_str(),
 271                                   apiStr->userdata);
 272     } else {
 273         LogInfo("installProgressCallback: ignoring NULL callback pointer");
 274     }
 275 }
 276 } //namespace
 277