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