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/assert.h>
  25 #include <installer_log.h>
  26
  27 namespace InstallerCallbacksTranslate {
  28
  29 // callback for finished install
  30 void installFinishedCallback(void *userParam,
  31                              std::string tizenId,
  32                              Jobs::Exceptions::Type status)
  33 {
  34     Assert(userParam != NULL);
  35
  36     StatusCallbackStruct *apiStr =
  37         static_cast<StatusCallbackStruct*>(userParam);
  38
  39     if (apiStr->status_callback) {
  40         // Translate error
  41         WrtErrStatus errorStatus;
  42
  43         switch (status) {
  44         case Jobs::Exceptions::Success:
  45             errorStatus = WRT_SUCCESS;
  46             break;
  47
  48         case Jobs::Exceptions::ErrorPackageNotFound:
  49             errorStatus = WRT_INSTALLER_ERROR_PACKAGE_NOT_FOUND;
  50             break;
  51
  52         case Jobs::Exceptions::ErrorPackageInvalid:
  53             errorStatus = WRT_INSTALLER_ERROR_PACKAGE_INVALID;
  54             break;
  55
  56         case Jobs::Exceptions::ErrorPackageLowerVersion:
  57             errorStatus = WRT_INSTALLER_ERROR_PACKAGE_LOWER_VERSION;
  58             break;
  59
  60         case Jobs::Exceptions::ErrorPackageExecutableNotFound:
  61             errorStatus = WRT_INSTALLER_ERROR_PACKAGE_EXCUTABLE_NOT_FOUND;
  62             break;
  63
  64         case Jobs::Exceptions::ErrorManifestNotFound:
  65             errorStatus = WRT_INSTALLER_ERROR_MANIFEST_NOT_FOUND;
  66             break;
  67
  68         case Jobs::Exceptions::ErrorManifestInvalid:
  69             errorStatus = WRT_INSTALLER_ERROR_MANIFEST_INVALID;
  70             break;
  71
  72         case Jobs::Exceptions::ErrorConfigNotFound:
  73             errorStatus = WRT_INSTALLER_CONFIG_NOT_FOUND;
  74             break;
  75
  76         case Jobs::Exceptions::ErrorConfigInvalid:
  77             errorStatus = WRT_INSTALLER_ERROR_CONFIG_INVALID;
  78             break;
  79
  80         case Jobs::Exceptions::ErrorSignatureNotFound:
  81             errorStatus = WRT_INSTALLER_ERROR_SIGNATURE_NOT_FOUND;
  82             break;
  83
  84         case Jobs::Exceptions::ErrorSignatureInvalid:
  85             errorStatus = WRT_INSTALLER_ERROR_SIGNATURE_INVALID;
  86             break;
  87
  88         case Jobs::Exceptions::ErrorSignatureVerificationFailed:
  89             errorStatus = WRT_INSTALLER_ERROR_SIGNATURE_VERIFICATION_FAILED;
  90             break;
  91
  92         case Jobs::Exceptions::ErrorRootCertificateNotFound:
  93             errorStatus = WRT_INSTALLER_ERROR_ROOT_CERTIFICATE_NOT_FOUND;
  94             break;
  95
  96         case Jobs::Exceptions::ErrorCertificationInvaid:
  97             errorStatus = WRT_INSTALLER_ERROR_CERTIFICATION_INVAID;
  98             break;
  99
 100         case
 101             Jobs::Exceptions::ErrorCertificateChainVerificationFailed:
 102             errorStatus =
 103             WRT_INSTALLER_ERROR_CERTIFICATE_CHAIN_VERIFICATION_FAILED;
 104             break;
 105
 106         case Jobs::Exceptions::ErrorCertificateExpired:
 107             errorStatus = WRT_INSTALLER_ERROR_CERTIFICATE_EXPIRED;
 108             break;
 109
 110         case Jobs::Exceptions::ErrorInvalidPrivilege:
 111             errorStatus = WRT_INSTALLER_ERROR_INVALID_PRIVILEGE;
 112             break;
 113
 114         case Jobs::Exceptions::ErrorPrivilegeLevelViolation:
 115             errorStatus = WRT_INSTALLER_ERROR_PRIVILEGE_LEVEL_VIOLATION;
 116             break;
 117
 118         case Jobs::Exceptions::ErrorMenuIconNotFound:
 119             errorStatus = WRT_INSTALLER_ERROR_MENU_ICON_NOT_FOUND;
 120             break;
 121
 122         case Jobs::Exceptions::ErrorFatalError:
 123             errorStatus = WRT_INSTALLER_ERROR_FATAL_ERROR;
 124             break;
 125
 126         case Jobs::Exceptions::ErrorOutOfStorage:
 127             errorStatus = WRT_INSTALLER_ERROR_OUT_OF_STORAGE;
 128             break;
 129
 130         case Jobs::Exceptions::ErrorOutOfMemory:
 131             errorStatus = WRT_INSTALLER_ERROR_OUT_OF_MEMORY;
 132             break;
 133
 134         case Jobs::Exceptions::ErrorArgumentInvalid:
 135             errorStatus = WRT_INSTALLER_ERROR_ARGUMENT_INVALID;
 136             break;
 137
 138         case Jobs::Exceptions::ErrorPackageAlreadyInstalled:
 139             errorStatus = WRT_INSTALLER_ERROR_PACKAGE_ALREADY_INSTALLED;
 140             break;
 141
 142         case Jobs::Exceptions::ErrorAceCheckFailed:
 143             errorStatus = WRT_INSTALLER_ERROR_ACE_CHECK_FAILED;
 144             break;
 145
 146         case Jobs::Exceptions::ErrorManifestCreateFailed:
 147             errorStatus = WRT_INSTALLER_ERROR_MANIFEST_CREATE_FAILED;
 148             break;
 149
 150         case Jobs::Exceptions::ErrorEncryptionFailed:
 151             errorStatus = WRT_INSTALLER_ERROR_ENCRYPTION_FAILED;
 152             break;
 153
 154         case Jobs::Exceptions::ErrorInstallOspServcie:
 155             errorStatus = WRT_INSTALLER_ERROR_INSTALL_OSP_SERVCIE;
 156             break;
 157
 158         default:
 159             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 160             break;
 161         }
 162
 163         // Callback
 164         apiStr->status_callback(tizenId, errorStatus, apiStr->userdata);
 165     } else {
 166         _D("installFinishedCallback: No callback");
 167     }
 168 }
 169
 170 // callback for finished install
 171 void uninstallFinishedCallback(void *userParam,
 172                                std::string tizenId,
 173                                Jobs::Exceptions::Type status)
 174 {
 175     Assert(userParam != NULL);
 176
 177     StatusCallbackStruct *apiStr =
 178         static_cast<StatusCallbackStruct*>(userParam);
 179
 180     if (apiStr->status_callback) {
 181         // Translate error
 182         WrtErrStatus errorStatus;
 183
 184         switch (status) {
 185         case Jobs::Exceptions::Success:
 186             errorStatus = WRT_SUCCESS;
 187             break;
 188
 189         case Jobs::Exceptions::ErrorWidgetUninstallationFailed:
 190             errorStatus = WRT_INSTALLER_ERROR_UNINSTALLATION_FAILED;
 191             break;
 192
 193         case Jobs::Exceptions::ErrorUnknown:
 194             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 195             break;
 196
 197         default:
 198             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 199             break;
 200         }
 201
 202         // Callback
 203         apiStr->status_callback(tizenId, errorStatus, apiStr->userdata);
 204     } else {
 205         _D("uninstallFinishedCallback: No callback");
 206     }
 207 }
 208
 209 void pluginInstallFinishedCallback(void *userParam,
 210                                    Jobs::Exceptions::Type status)
 211 {
 212     Assert(userParam);
 213
 214     PluginStatusCallbackStruct *apiStr =
 215         static_cast<PluginStatusCallbackStruct*>(userParam);
 216
 217     if (apiStr->statusCallback) {
 218         // Translate error
 219         WrtErrStatus errorStatus;
 220
 221         switch (status) {
 222         case Jobs::Exceptions::Success:
 223             errorStatus = WRT_SUCCESS;
 224             break;
 225         case Jobs::Exceptions::ErrorPluginInstallationFailed:
 226             errorStatus = WRT_INSTALLER_ERROR_PLUGIN_INSTALLATION_FAILED;
 227             break;
 228         default:
 229             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 230             break;
 231         }
 232
 233         apiStr->statusCallback(errorStatus, apiStr->userdata);
 234     } else {
 235         _D("PluginInstallFinishedCallback: No callback");
 236     }
 237
 238     delete apiStr;
 239 }
 240
 241 // callback for progress of install OR uninstall
 242 void installProgressCallback(void *userParam,
 243                              ProgressPercent percent,
 244                              const ProgressDescription &description)
 245 {
 246     Assert(userParam != NULL);
 247
 248     StatusCallbackStruct *apiStr =
 249         static_cast<StatusCallbackStruct*>(userParam);
 250
 251     if (apiStr->progress_callback) {
 252         //CALLBACK EXEC
 253         _D("Entered %2.0f%% %s", percent, description.c_str());
 254         apiStr->progress_callback(static_cast<float>(percent),
 255                                   description.c_str(),
 256                                   apiStr->userdata);
 257     } else {
 258         _D("installProgressCallback: ignoring NULL callback pointer");
 259     }
 260 }
 261 } //namespace
 262