src/app/FApp_Aul.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   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 /**
  18  * @file         FApp_Aul.cpp
  19  * @brief       This is the implementation for the _Aul.cpp class.
  20  */
  21 #include <cstdio>
  22 #include <cstdlib>
  23 #include <new>
  24 #include <unistd.h>
  25 #include <sys/prctl.h>
  26 #include <signal.h>
  27 #include <unique_ptr.h>
  28
  29 #include <aul.h>
  30 #include <bundle.h>
  31 #include <appsvc/appsvc.h>
  32 #include <vconf.h>
  33
  34 #include <FBaseObject.h>
  35 #include <FBaseString.h>
  36 #include <FBaseUtil.h>
  37 #include <FBaseSysLog.h>
  38 #include <FBaseColHashMapT.h>
  39 #include <FAppPkgPackageInfo.h>
  40
  41 #include <FBaseRt_Process.h>
  42 #include <FBase_StringConverter.h>
  43 #include "FAppPkg_PackageManagerImpl.h"
  44 #include "FApp_Types.h"
  45 #include "FApp_Aul.h"
  46 #include "FApp_AppArg.h"
  47 #include "FApp_TemplateUtil.h"
  48
  49
  50 using namespace Tizen::App::Package;
  51 using namespace Tizen::Base;
  52 using namespace Tizen::Base::Collection;
  53 using namespace Tizen::Base::Runtime;
  54 using namespace Tizen::Base::Utility;
  55
  56 namespace
  57 {
  58 const int _MAX_CATEGORY = 34;
  59
  60 // borrowed from app-svc/include/pri_key.h
  61 #define APP_SVC_K_RES_VAL       "__APP_SVC_K_RES_VAL__"
  62
  63 }
  64
  65 namespace Tizen { namespace App
  66 {
  67
  68 struct _CategoryList
  69 {
  70         const char category[_MAX_CATEGORY];
  71         const _AppType type;
  72 };
  73
  74 static const _CategoryList _CATEGORY_LIST[] =
  75 {
  76         {"home-screen", _APP_TYPE_HOME_APP},
  77         {"lock-screen", _APP_TYPE_LOCK_APP},
  78         {"ime", _APP_TYPE_IME_APP},
  79         {"http://tizen.org/category/homeapp", _APP_TYPE_HOME_APP},
  80         {"http://tizen.org/category/lockapp", _APP_TYPE_LOCK_APP},
  81         {"http://tizen.org/category/ime", _APP_TYPE_IME_APP},
  82 };
  83
  84 static const int _NUM_CATEGORY = sizeof(_CATEGORY_LIST) / sizeof(_CategoryList);
  85
  86 result
  87 _Aul::GetConvertedResult(const int aul_ret, const char* pFunctionName)
  88 {
  89         result r = E_SUCCESS;
  90
  91         switch (aul_ret)
  92         {
  93         case AUL_R_EINVAL:
  94                 r = E_INVALID_ARG;
  95                 SysLogException(NID_APP, r, "%s : Invalid argument.", pFunctionName);
  96                 break;
  97
  98         case AUL_R_ECOMM:
  99                 r = E_SYSTEM;
 100                 SysLogException(NID_APP, r, "%s : Internal IPC error.", pFunctionName);
 101                 break;
 102
 103         case AUL_R_ERROR:
 104                 r = E_SYSTEM;
 105                 SysLogException(NID_APP, r, "%s : General error.", pFunctionName);
 106                 break;
 107
 108         default:
 109                 SysLog(NID_APP, "%s : successed.", pFunctionName);
 110                 break;
 111         }
 112
 113         return r;
 114 }
 115
 116 result
 117 _Aul::SendResult(bundle* b, appsvc_result_val res, bool isSubMode, bool isServiceApp)
 118 {
 119         // to skip error handling, of appsvc_send_result, use aul_send_service_result() directly.
 120         //int ret = appsvc_send_result(b, res);
 121
 122         char tmp[32] = {0, };
 123         snprintf(tmp, 32, "%d", static_cast<int>(res));
 124         appsvc_add_data(b, APP_SVC_K_RES_VAL, tmp);
 125
 126         if (isSubMode)
 127         {
 128                 _AppArg::UpdateSubMode(b);
 129         }
 130
 131         if (isServiceApp)
 132         {
 133                 _AppArg::UpdateServiceApp(b);
 134         }
 135
 136         const int aul_ret = aul_send_service_result(b);
 137
 138         result r = GetConvertedResult(aul_ret, "SendResult");
 139         if (r == E_INVALID_ARG)
 140         {
 141                 SysLog(NID_APP, "Converting internal exception to E_MAX_EXCEEDED.");
 142                 r = E_MAX_EXCEEDED;
 143         }
 144         return r;
 145 }
 146
 147
 148 bool
 149 _Aul::IsRunning(const String& appId)
 150 {
 151         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(appId));
 152
 153         const bool isRunning = (aul_app_is_running(pPackageId.get()) > 0);
 154
 155         SysLog(NID_APP, "'%ls' %s running now.", appId.GetPointer(), (isRunning) ? "is" : "is NOT");
 156         return isRunning;
 157 }
 158
 159
 160 result
 161 _Aul::TerminateApplicationByPid(int pid)
 162 {
 163         int ret_aul = aul_subapp_terminate_request_pid(pid);
 164
 165         return GetConvertedResult(ret_aul, "TerminateApplicationByPid");
 166 }
 167
 168 static int
 169 TerminateApplicationIterFnCb(const aul_app_info* pAppInfo, void* pData)
 170 {
 171         const char* pStr = static_cast<const char*>(pData);
 172
 173         if (pStr && strncmp(pStr, pAppInfo->pkg_name, NATIVE_APP_MAX_APPID_LENGTH) == 0)
 174         {
 175                 SysLog(NID_APP, "%s(%d) is terminated.", pAppInfo->pkg_name, pAppInfo->pid);
 176                 int ret_aul = aul_terminate_pid( pAppInfo->pid );
 177                 SetLastResult(_Aul::GetConvertedResult(ret_aul, "TerminateApplication"));
 178         }
 179         return 0;
 180 }
 181
 182 result
 183 _Aul::TerminateApplication(const AppId& appId)
 184 {
 185         SetLastResult(E_OBJ_NOT_FOUND);
 186         std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
 187         aul_app_get_running_app_info(TerminateApplicationIterFnCb, static_cast<void*>(pAppId.get()));
 188
 189         SysLog(NID_APP, "%ls terminated.", appId.GetPointer());
 190         return GetLastResult();
 191 }
 192
 193 result
 194 _Aul::SetOomAdj(int pid, int adj)
 195 {
 196         // set oom_adj to -17 for system service
 197         result r = E_SUCCESS;
 198         char buf[FILENAME_MAX];
 199         FILE *fP = NULL;
 200
 201         snprintf(buf, FILENAME_MAX, "/proc/%d/oom_adj", pid);
 202         fP = fopen(buf, "w");
 203         SysTryReturnResult(NID_APP, fP != NULL, E_SYSTEM, "oom_adj change failed with %s.", strerror(errno));
 204
 205         fprintf(fP, "%d", adj);
 206         fclose(fP);
 207
 208         return r;
 209 }
 210
 211 typedef void (* cbForVconf)(keynode_t* node, void *pData);
 212
 213 result
 214 _Aul::SetPowerOffNotiListener( void (*powerOffCb)(void* node, void *pData), void *pData)
 215 {
 216
 217 #if 1
 218         int ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_POWER_OFF_STATUS, (cbForVconf)powerOffCb, pData);
 219         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to set power off");
 220 #else
 221         int heyFd = heynoti_init();
 222         SysTryReturnResult(NID_APP, heyFd >= 0, E_SYSTEM, "heynoti_init failed.");
 223
 224         int ret = heynoti_subscribe(heyFd, "power_off_start", powerOffCb, pData);
 225         SysTryReturnResult(NID_APP, ret >= 0, E_SYSTEM, "heynoti_subscribe failed.");
 226
 227         ret = heynoti_attach_handler(heyFd);
 228         SysTryReturnResult(NID_APP, ret >= 0, E_SYSTEM, "heynoti_attach_handler failed.");
 229 #endif
 230
 231         return E_SUCCESS;
 232 }
 233
 234
 235 // _Aul::GetAppType is provided for installer usage
 236 int
 237 _Aul::GetAppType(const String& category)
 238 {
 239         int ret = 0;
 240
 241         HashMapT<String, int> map;
 242         map.Construct();
 243
 244         StringTokenizer strTok(category, L';');
 245
 246         String token;
 247         while (strTok.HasMoreTokens())
 248         {
 249                 result r = strTok.GetNextToken(token);
 250                 if (r == E_SUCCESS)
 251                 {
 252                         map.Add(token, 0);
 253                 }
 254         }
 255
 256         SysLog(NID_APP, "%d category items .", map.GetCount());
 257
 258         String key;
 259
 260         for (int i = 0; i < _NUM_CATEGORY; i++)
 261         {
 262                 bool b = false;
 263                 key = _CATEGORY_LIST[i].category;
 264                 result r = map.ContainsKey(key, b);
 265                 if (r == E_SUCCESS && b)
 266                 {
 267                         ret |= _CATEGORY_LIST[i].type;
 268                 }
 269         }
 270
 271         return ret;
 272 }
 273
 274
 275 bool
 276 _Aul::IsInstalled(const AppId& appId)
 277 {
 278         String packageId;
 279         packageId = _PackageManagerImpl::GetPackageIdByAppId(appId);
 280
 281         return _PackageManagerImpl::GetInstance()->IsPackageInstalled(packageId);
 282 }
 283
 284
 285 AppId
 286 _Aul::GetRealAppId(const AppId& appId)
 287 {
 288         String temp;
 289         // [INFO] ugly code for submode callee
 290         appId.SubString(11, temp);
 291         if (temp == L"_AppControl")
 292         {
 293                 String id;
 294                 appId.SubString(0, 10, id);
 295                 const String& name = _PackageManagerImpl::GetInstance()->GetDefaultAppExecutableName(id);
 296
 297                 const String retVal = id + L'.' + name;
 298                 SysLog(NID_APP, "Converted caller Id is %ls", retVal.GetPointer());
 299
 300                 return retVal;
 301         }
 302         else
 303         {
 304                 return appId;
 305         }
 306 }
 307
 308 } } // Tizen::App