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         case Jobs::Exceptions::ErrorInstallPrivilegeUsingLegacyFailed:
 159             errorStatus = WGT_INSTALLER_ERR_PRIVILEGE_USING_LEGACY_FAILED;
 160             break;
 161
 162         case Jobs::Exceptions::ErrorInstallPrivilegeUnknownFailed:
 163             errorStatus = WGT_INSTALLER_ERR_PRIVILEGE_UNKNOWN_FAILED;
 164             break;
 165
 166         case Jobs::Exceptions::ErrorInstallPrivilegeUnauthorizedFailed:
 167             errorStatus = WGT_INSTALLER_ERR_PRIVILEGE_UNAUTHORIZED_FAILED;
 168             break;
 169
 170         default:
 171             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 172             break;
 173         }
 174
 175         // Callback
 176         apiStr->status_callback(tizenId, errorStatus, apiStr->userdata);
 177     } else {
 178         _D("installFinishedCallback: No callback");
 179     }
 180 }
 181
 182 // callback for finished install
 183 void uninstallFinishedCallback(void *userParam,
 184                                std::string tizenId,
 185                                Jobs::Exceptions::Type status)
 186 {
 187     Assert(userParam != NULL);
 188
 189     StatusCallbackStruct *apiStr =
 190         static_cast<StatusCallbackStruct*>(userParam);
 191
 192     if (apiStr->status_callback) {
 193         // Translate error
 194         WrtErrStatus errorStatus;
 195
 196         switch (status) {
 197         case Jobs::Exceptions::Success:
 198             errorStatus = WRT_SUCCESS;
 199             break;
 200
 201         case Jobs::Exceptions::ErrorWidgetUninstallationFailed:
 202             errorStatus = WRT_INSTALLER_ERROR_UNINSTALLATION_FAILED;
 203             break;
 204
 205         case Jobs::Exceptions::ErrorUnknown:
 206             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 207             break;
 208
 209         default:
 210             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 211             break;
 212         }
 213
 214         // Callback
 215         apiStr->status_callback(tizenId, errorStatus, apiStr->userdata);
 216     } else {
 217         _D("uninstallFinishedCallback: No callback");
 218     }
 219 }
 220
 221 void pluginInstallFinishedCallback(void *userParam,
 222                                    Jobs::Exceptions::Type status)
 223 {
 224     Assert(userParam);
 225
 226     PluginStatusCallbackStruct *apiStr =
 227         static_cast<PluginStatusCallbackStruct*>(userParam);
 228
 229     if (apiStr->statusCallback) {
 230         // Translate error
 231         WrtErrStatus errorStatus;
 232
 233         switch (status) {
 234         case Jobs::Exceptions::Success:
 235             errorStatus = WRT_SUCCESS;
 236             break;
 237         case Jobs::Exceptions::ErrorPluginInstallationFailed:
 238             errorStatus = WRT_INSTALLER_ERROR_PLUGIN_INSTALLATION_FAILED;
 239             break;
 240         default:
 241             errorStatus = WRT_INSTALLER_ERROR_UNKNOWN;
 242             break;
 243         }
 244
 245         apiStr->statusCallback(errorStatus, apiStr->userdata);
 246     } else {
 247         _D("PluginInstallFinishedCallback: No callback");
 248     }
 249
 250     delete apiStr;
 251 }
 252
 253 // callback for progress of install OR uninstall
 254 void installProgressCallback(void *userParam,
 255                              ProgressPercent percent,
 256                              const ProgressDescription &description)
 257 {
 258     Assert(userParam != NULL);
 259
 260     StatusCallbackStruct *apiStr =
 261         static_cast<StatusCallbackStruct*>(userParam);
 262
 263     if (apiStr->progress_callback) {
 264         //CALLBACK EXEC
 265         _D("Entered %2.0f%% %s", percent, description.c_str());
 266         apiStr->progress_callback(static_cast<float>(percent),
 267                                   description.c_str(),
 268                                   apiStr->userdata);
 269     } else {
 270         _D("installProgressCallback: ignoring NULL callback pointer");
 271     }
 272 }
 273 } //namespace
 274