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