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(int widget_handle,
  61         CommonError::Type result,
  62         void *data)
  63 {
  64     LogDebug("StatusCallback called  " << widget_handle << " | " << 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(widget_handle,
  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         WidgetHandle widget_handle,
  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::ErrorFactoryWidget:
 110             errorStatus = WRT_INSTALLER_ERROR_FACTORY_WIDGET;
 111             break;
 112
 113         case Jobs::WidgetInstall::Exceptions::ErrorAreadyUninstalling:
 114             errorStatus = WRT_INSTALLER_ERROR_ALREADY_UNINSTALLING;
 115             break;
 116
 117         case Jobs::WidgetInstall::Exceptions::ErrorOutOfDiskSpace:
 118             errorStatus = WRT_INSTALLER_ERROR_OUT_OUT_DISK_SPACE;
 119             break;
 120
 121         case Jobs::WidgetInstall::Exceptions::ErrorInvalidPackage:
 122             errorStatus = WRT_INSTALLER_ERROR_INVALID_CERTIFICATE;
 123             break;
 124
 125         case Jobs::WidgetInstall::Exceptions::ErrorAlreadyInstalled:
 126             errorStatus = WRT_INSTALLER_ERROR_ALREADY_INSTALLED;
 127             break;
 128
 129         case Jobs::WidgetInstall::Exceptions::ErrorInternal:
 130             errorStatus = WRT_INSTALLER_ERROR_INTERNAL;
 131             break;
 132
 133         case Jobs::WidgetInstall::Exceptions::ErrorNotAllowed:
 134             errorStatus = WRT_INSTALLER_ERROR_NOT_ALLOWED;
 135             break;
 136
 137         case Jobs::WidgetInstall::Exceptions::ErrorDeferred:
 138             errorStatus = WRT_INSTALLER_ERROR_DEFERRED;
 139             break;
 140
 141         case Jobs::WidgetInstall::Exceptions::ErrorDatabaseFailure:
 142             errorStatus = WRT_INSTALLER_ERROR_DATABASE_FAILURE;
 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(widget_handle, errorStatus, apiStr->userdata);
 156     } else {
 157         LogInfo("installFinishedCallback: No callback");
 158     }
 159 }
 160
 161 // callback for finished install
 162 void uninstallFinishedCallback(void *userParam,
 163         WidgetHandle widget_handle,
 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::WidgetInstall::Exceptions::ErrorAreadyUninstalling:
 181         //     errorStatus = WRT_INSTALLER_ERROR_ALREADY_UNINSTALLING;
 182         //     break;
 183
 184         case Jobs::WidgetUninstall::Exceptions::ErrorDatabaseFailure:
 185             errorStatus = WRT_INSTALLER_ERROR_DATABASE_FAILURE;
 186             break;
 187
 188         case Jobs::WidgetUninstall::Exceptions::ErrorUnknown:
 189             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 190             break;
 191
 192         default:
 193             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 194             break;
 195         }
 196
 197         // Callback
 198         apiStr->status_callback(widget_handle, errorStatus, apiStr->userdata);
 199     } else {
 200         LogInfo("uninstallFinishedCallback: No callback");
 201     }
 202 }
 203
 204 void pluginInstallFinishedCallback(void *userParam,
 205         Jobs::PluginInstall::Exceptions::Type status)
 206 {
 207     Assert(userParam);
 208
 209     PluginStatusCallbackStruct *apiStr =
 210         static_cast<PluginStatusCallbackStruct*>(userParam);
 211
 212     if (apiStr->statusCallback) {
 213         // Translate error
 214         WrtErrStatus errorStatus;
 215
 216         switch (status) {
 217         case Jobs::PluginInstall::Exceptions::Success:
 218             errorStatus = WRT_SUCCESS;
 219             break;
 220         case Jobs::PluginInstall::Exceptions::WrongPluginPath:
 221             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_WRONG_PATH;
 222             break;
 223         case Jobs::PluginInstall::Exceptions::MetafileError:
 224             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_METAFILE;
 225             break;
 226         case Jobs::PluginInstall::Exceptions::AlreadyInstalled:
 227             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_ALREADY_INSTALLED;
 228             break;
 229         case Jobs::PluginInstall::Exceptions::LoadingLibraryError:
 230             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_LIBRARY_ERROR;
 231             break;
 232         case Jobs::PluginInstall::Exceptions::InstallationWaiting:
 233             errorStatus = WRT_PLUGIN_INSTALLER_ERROR_WAITING;
 234             break;
 235         default:
 236             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 237             break;
 238         }
 239
 240         apiStr->statusCallback(errorStatus, apiStr->userdata);
 241     } else {
 242         LogInfo("PluginInstallFinishedCallback: No callback");
 243     }
 244
 245     delete apiStr;
 246 }
 247
 248 // callback for progress of install OR uninstall
 249 void installProgressCallback(void *userParam,
 250         ProgressPercent percent,
 251         const ProgressDescription &description)
 252 {
 253     Assert(userParam != NULL);
 254
 255     StatusCallbackStruct *apiStr =
 256         static_cast<StatusCallbackStruct*>(userParam);
 257
 258     if (apiStr->progress_callback) {
 259         //CALLBACK EXEC
 260         LogInfo("Entered " << percent << "% " << description);
 261         apiStr->progress_callback(static_cast<float>(percent),
 262                                   description.c_str(),
 263                                   apiStr->userdata);
 264     } else {
 265         LogInfo("installProgressCallback: ignoring NULL callback pointer");
 266     }
 267 }
 268
 269 } //namespace
 270