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