result
+_AppArg::Construct(const _AppMessageImpl& msg, const String& oId, const String* pUri, const String* pMime)
+{
+ __pBundle = bundle_dup(const_cast<bundle*>(msg.GetBundle()));
+ SysTryReturnResult(NID_APP, __pBundle != null, E_OUT_OF_MEMORY, "Bundle creation failure.");
+
+ return CreateAppControlArg(__pBundle, oId, pUri, pMime, null);
+}
+
+
+result
_AppArg::Construct(const _SqlDataControlImpl& dc, _DataControlRequestType requestType, const IList* pList)
{
__pBundle = bundle_create();
return null;
}
- ArrayList* pList = _AppMessageImpl::GetValueArray(__pBundle, OSP_K_ARG);
+ ArrayList* pList = _AppMessageImpl::GetValueArrayN(__pBundle, OSP_K_ARG);
if (pList)
{
pHashMap->Add(new (std::nothrow) String(TIZEN_APPCONTROL_DATA_LEGACY), pList);
result
-_AppArg::CreateAppControlArg(bundle* b, const _AppControlImpl& ac, const String* pUriData, const String* pMimeType, const IMap* pList)
+_AppArg::CreateAppControlArg(bundle* b, const _AppControlImpl& ac, const String* pUriData, const String* pMimeType, const IMap* pMap)
+{
+ return CreateAppControlArg(b, ac._opId, pUriData, pMimeType, pMap);
+}
+
+
+result
+_AppArg::CreateAppControlArg(bundle* b, const String& oId, const String* pUriData, const String* pMimeType, const IMap* pMap)
{
SysAssertf(b != null, "Valid bundle should be supplied");
bundle* pb = b;
- std::unique_ptr<char[]> pOperation(_StringConverter::CopyToCharArrayN(ac._opId));
+ std::unique_ptr<char[]> pOperation(_StringConverter::CopyToCharArrayN(oId));
if (pOperation.get())
{
appsvc_set_operation(pb, pOperation.get());
}
}
- AddStrMap(pb, pList);
+ AddStrMap(pb, pMap);
bundle_add(pb, OSP_K_LAUNCH_TYPE, OSP_V_LAUNCH_TYPE_APPCONTROL);
delete __pArg;
}
-_NativeAppControlEventArg::_NativeAppControlEventArg(int reqId, int res, const IMap* pArg)
+_NativeAppControlEventArg::_NativeAppControlEventArg(int reqId, int res, IMap* pArg)
: __reqId(reqId)
, __result(res)
, __pArgs(null)
return;
}
+#if 0
HashMap* pMap = new (std::nothrow) HashMap(SingleObjectDeleter);
SysTryReturnVoidResult(NID_APP, pMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
}
__pArgs = pMap;
+#else
+ // ownership is transferred to event
+ __pArgs = pArg;
+#endif
return;
}
, public Tizen::Base::Runtime::IEventArg
{
public:
- _NativeAppControlEventArg(int reqId, int res, const Tizen::Base::Collection::IMap* pArgs);
+ _NativeAppControlEventArg(int reqId, int res, Tizen::Base::Collection::IMap* pArgs);
virtual ~_NativeAppControlEventArg(void);
result
_AppControlImpl::AppControlCb(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int reqId)
{
- SysLog(NID_APP, "Result value %d", res);
+ SysLog(NID_APP, "Result value : %d, property : 0x%x", res, prop);
SysTryReturnResult(NID_APP, data && pResArg && pArg, E_SYSTEM, "Invalid result (callback, result, arg) = (0x%x, 0x%x, 0x%x).",
data, pResArg,
if (prop & _APPCONTROL_PROPERTY_ALIAS)
{
+ SysLog(NID_APP, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
const _AppControlRegistry::_AppControlAliasEntry* pEntry = null;
- pEntry = _AppControlRegistry::GetInstance()->GetReverseAppControlAliasEntry(provider, oId);
+ pEntry = _AppControlRegistry::GetInstance()->GetReverseRuntimeAliasEntry(provider, oId);
if (pEntry)
{
provider = pEntry->provider;
oId = pEntry->operation;
- SysLog(NID_APP, "Legacy AppControl name (%ls, %ls).", provider.GetPointer(), oId.GetPointer());
+ SysLog(NID_APP, "Original AppControl name (%ls, %ls).", provider.GetPointer(), oId.GetPointer());
}
+ SysLog(NID_APP, "CCCCCCCCCCCCCCCCCCCCCCCCCCCCC 0x%x", pEntry);
}
if (prop & _APPCONTROL_PROPERTY_APPID_CHANGE)
}
-result
-_AppControlManager::LaunchPkg(_AppMessageImpl& msg, const String& package, const String& opId, const String* pUri, const String* pMime, AppSvcResFn pCb, void* data)
+int
+_AppControlManager::LaunchPkg(_AppMessageImpl& msg, const AppId& appId, const String& opId, const String* pUri, const String* pMime, AppSvcResFn pCb, void* data)
{
- std::unique_ptr<char[]> pPackage(_StringConverter::CopyToCharArrayN(package));
+ std::unique_ptr<char[]> pPackage(_StringConverter::CopyToCharArrayN(appId));
std::unique_ptr<char[]> pOperation(_StringConverter::CopyToCharArrayN(opId));
const char* pUriData = null;
pMimeData = _StringConverter::CopyToCharArrayN(*pMime);
}
- result r = LaunchPkg(msg, pPackage.get(), pOperation.get(), pMimeData, pUriData, pCb, data);
+ int pid = Launch(msg, pPackage.get(), pOperation.get(), pMimeData, pUriData, pCb, data);
delete [] pUriData;
delete [] pMimeData;
- return r;
+ return pid;
}
return false;
}
+
+int
+_AppControlManager::Launch(const _AppMessageImpl& msg, const AppId& aId, const String& oId, const String* pUriData, const String* pMimeType, AppSvcResFn pCb, void* pData)
+{
+ SysLog(NID_APP, "Enter");
+
+ _AppArg arg;
+ arg.Construct(msg, oId, pUriData, pMimeType);
+
+ int pid = Launch(aId, &arg, pCb, pData, -1);
+ SysTryReturn(NID_APP, pid >= 0, -1, GetLastResult(), "Launching(%ls) is failed", aId.GetPointer());
+
+ SysLog(NID_APP, "Exit");
+
+ return pid;
+}
+
+
int
_AppControlManager::Launch(const AppId& appId, _AppArg* pArg, int req)
{
+ return Launch(appId, pArg, reinterpret_cast<AppSvcResFn>(LaunchResultCb), this, req);
+}
+
+
+int
+_AppControlManager::Launch(const AppId& appId, _AppArg* pArg, AppSvcResFn pCb, void* pData, int req)
+{
SysTryReturn(NID_APP, pArg != null, -1, E_INVALID_ARG, "[E_INVALID_ARG] Invalid launch argument");
SysLog(NID_APP, "AppId: %ls.", appId.GetPointer());
pArg->UpdateAppId(tempId);
kb = pArg->GetBundle();
- pid = appsvc_run_service(kb, req, LaunchResultCb, this);
+ pid = appsvc_run_service(kb, req, reinterpret_cast<appsvc_res_fn>(pCb), pData);
if (pid > 0)
{
SysLog(NID_APP, "Submode launch successful");
do
{
kb = pArg->GetBundle();
- pid = appsvc_run_service(kb, req, LaunchResultCb, this);
+ pid = appsvc_run_service(kb, req, reinterpret_cast<appsvc_res_fn>(pCb), pData);
if (pid > 0)
{
SysLog(NID_APP, "Application(%d) launched with reqId(%d) and arg(0x%x).", pid, req, pArg);
}
void
-_AppControlManager::FinishAppControl(int reqId, int res, const IMap* pMap)
+_AppControlManager::FinishAppControl(int reqId, int res, IMap* pMap)
{
SysLog(NID_APP, "Enter.");
_NativeAppControlEventArg* pArg = new (std::nothrow) _NativeAppControlEventArg(reqId, res, pMap);
bool
-_AppControlManager::IsAllowedAppControl(const wchar_t aTable[][2][64], int count, const String& aId, const String& oId)
+_AppControlManager::IsAllowedAppControl(const char aTable[][2][96], int count, const String& aId, const String& oId)
{
for (int i = 0; i < count; i++)
{
if (aId == aTable[i][0] && oId == aTable[i][1])
{
- SysLog(NID_APP, "Found entry (%ls, %ls)", aTable[i][0], aTable[i][1]);
+ SysLog(NID_APP, "Found entry (%s, %s)", aTable[i][0], aTable[i][1]);
return true;
}
}
const wchar_t TIZEN_ALIAS_APPID_PREFIX[] = L"tizen.";
-const String ACTL_REGISTRY_OP_NUM = L"OPID_Count";
const String ACTL_REGISTRY_PUBLIC = L"Public";
const String ACTL_REGISTRY_PATH = L"Path";
-const String ACTL_REGISTRY_TITLE = L"Title";
const String ACTL_REGISTRY_ALIAS_PROVIDER = L"PROVIDER_ALIAS";
-const int PKG_CATEGORY_LEN = 256;
const int PKG_APPID_LEN = 256;
const int REG_VALUE_BUFFER_LEN = 256;
_AppControlRegistry::_AppControlRegistry(void)
{
- __nativeList.Construct();
-
__tizenList.Construct();
__aliasList.Construct();
__aliasAppId.Construct();
+
+ __runtimeAlias.Construct();
}
_AppControlRegistry::~_AppControlRegistry(void)
{
- _DeleteCollection<AppControl>(__nativeList);
-
_DeleteCollectionMapValue<String, _AppControlAliasEntry>(__aliasList);
+
+ _DeleteCollection<_AppControlAliasEntry>(__runtimeAlias);
}
_AppControlRegistry*
SysTryReturn(NID_APP, __pSelf != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
SysAssertf(__pSelf != null, "AppControl registry instance creation failure");
- __pSelf->LoadRegistry();
-
__pSelf->LoadTizenAppControlRegistry();
__pSelf->LoadLegacyList();
return __pSelf;
}
-result
-_AppControlRegistry::LoadRegistry(void)
-{
- _RegistryImpl reg;
-
- const String regPath = ACTL_DEFAULT_FILE;
-
- result r = reg.Construct(regPath, REG_OPEN_READ_ONLY, null);
- SysTryReturn(NID_APP, !IsFailed(r), r, r, "[%s] Propagating.", GetErrorMessage(r));
-
- const int sec_count = reg.GetAllSectionCount();
- SysTryReturnResult(NID_APP, !(sec_count <= 0), E_OBJ_NOT_FOUND, "Registry contains no data.");
-
- SysLog(NID_APP, "Loading %d sections from %ls", sec_count, regPath.GetPointer());
-
- int index = 0;
- int size = 0;
- int num = 0;
- String actl_path;
- String actl_name;
-
-
- // actual parameter manipulation
- for (int i = 0; i < sec_count; i++)
- {
- ///////////////////////////////////////////////////////////////////////
- // appcontrol Id
- String sec_name(reg.GetSectionName(i));
- sec_name.Trim();
-
- if (sec_name.IsEmpty())
- {
- continue;
- }
-
- int public_open = 0;
-
- ///////////////////////////////////////////////////////////////////////
- // Plubic
- index = reg.GetEntryIndex(i, ACTL_REGISTRY_PUBLIC);
- if (index >= 0)
- {
- size = sizeof(size);
- num = 0;
-
- reg.GetEntryValue(i, index, REG_VALUE_TYPE_INT, &num, &size);
- if (num == 1)
- {
- // public
- public_open = 1;
- }
- }
-
- ///////////////////////////////////////////////////////////////////////
- // Path
- index = reg.GetEntryIndex(i, ACTL_REGISTRY_PATH);
- if (index >= 0)
- {
- size = REG_VALUE_BUFFER_LEN;
- reg.GetEntryValue(i, index, REG_VALUE_TYPE_STRING, &actl_path, &size);
- }
-
- ///////////////////////////////////////////////////////////////////////
- // Name
- // [FIXME] SLP localized name here
- index = reg.GetEntryIndex(i, ACTL_REGISTRY_TITLE);
- if (index >= 0)
- {
- size = REG_VALUE_BUFFER_LEN;
- reg.GetEntryValue(i, index, REG_VALUE_TYPE_STRING, &actl_name, &size);
- }
-
- //SysLog(NID_APP, "%dth iteration : %ls", i, sec_name.GetPointer());
-
- ///////////////////////////////////////////////////////////////////////
- // Number of operation Id
- index = reg.GetEntryIndex(i, ACTL_REGISTRY_OP_NUM);
- if (index >= 0)
- {
- size = sizeof(size);
- reg.GetEntryValue(i, index, REG_VALUE_TYPE_INT, &num, &size);
-
- String tagName;
- String actl_opId;
-
- //SysLog(NID_APP, "number of operation %d for index %d", num, index);
-
- for (int j = 0; j < num; j++)
- {
- size = REG_VALUE_BUFFER_LEN;
-
- ///////////////////////////////////////////////////////////////
- // operation Id
- tagName.Format(10, L"OPID_%d", j);
-
- index = reg.GetEntryIndex(i, tagName);
- if (index >= 0)
- {
- reg.GetEntryValue(i, index, REG_VALUE_TYPE_STRING, &actl_opId, &size);
- actl_opId.Trim();
- }
- //SysLog(NID_APP, "Operation(%d) %ls", index, actl_opId.GetPointer());
-
- ///////////////////////////////////////////////////////////////
- // AppControl allocation
-
- int prop = 0;
- if (public_open == 1)
- {
- prop |= _APPCONTROL_PROPERTY_PUBLIC;
- }
-
- prop |= _APPCONTROL_PROPERTY_SLP;
-
- //SysLog(NID_APP, "(%ls, %ls)", sec_name.GetPointer(), actl_opId.GetPointer());
- AppControl* pAc = _AppControlImpl::CreateN(actl_path, sec_name, actl_opId, actl_name, prop);
-
- if (pAc)
- {
- __nativeList.Add(pAc);
- }
- else
- {
- SysLog(NID_APP, "Failed to create AppControl instance (%ls, %ls, %d)",
- sec_name.GetPointer(), actl_opId.GetPointer(), public_open);
- }
- }
- }
-
- }
-
- SysLog(NID_APP, "Finished loading %d entries", __nativeList.GetCount());
-
- return E_SUCCESS;
-}
result
_AppControlRegistry::LoadTizenAppControlRegistry(void)
AppControl*
-_AppControlRegistry::GetTizenAppControlN(const String& aId, const String& oId) const
+_AppControlRegistry::GetTizenAppControlN(const String& aId, const String& oId)
{
- const _AppControlAliasEntry* pEntry = null;
int count = 0;
-
+ const String* pAppId = &aId;
+ const String* pOperation = &oId;
do
{
- const _AppControlAliasEntry* pTempEntry = GetAppControlAliasEntry(aId, oId);
+ const _AppControlAliasEntry* const pEntry = GetAppControlAliasEntry(*pAppId, *pOperation);
// number does not matter
- if (count >= 5 || pTempEntry == null)
+ if (count >= 5 || pEntry == null)
{
break;
}
- pEntry = pTempEntry;
+ pAppId = &pEntry->provider2;
+ pOperation = &pEntry->operation2;
count++;
}
while (true);
- const String* pAppId = null;
- const String* pOperation = null;
-
- if (count == 0)
- {
- // if count is 0, then no alias is found
- pAppId = &aId;
- pOperation = &oId;
- }
- else if (pEntry == null)
- {
- // no "TIZEN" AppControl
- return null;
- }
- else
- {
- pAppId = &pEntry->provider2;
- pOperation = &pEntry->operation2;
- }
-
SysAssert(pAppId != null);
SysAssert(pOperation != null);
if (soName.IsEmpty())
{
- SysLog(NID_APP, "No AppControl stub found for (%ls, %ls)", pAppId->GetPointer(), pOperation->GetPointer());
- return null;
+ AppControl* pAc = GetAppControlN(*pAppId, *pOperation);
+ if (pAc)
+ {
+ _AppControlImpl* pImpl = _AppControlImpl::GetInstance(*pAc);
+ pImpl->SetProperty(_APPCONTROL_PROPERTY_ALIAS);
+
+ _AppControlAliasEntry* pEntry = new (std::nothrow) _AppControlAliasEntry(aId, oId, *pAppId, *pOperation);
+ if (pEntry)
+ {
+ // may fail
+ __runtimeAlias.Add(pEntry);
+ SysLog(NID_APP, "Setting alias appId (%ls -> %ls).", aId.GetPointer(), pAppId->GetPointer());
+ }
+ }
+ else
+ {
+ SysLog(NID_APP, "No AppControl instance for (%ls, %ls)", pAppId->GetPointer(), pOperation->GetPointer());
+ }
+ return pAc;
}
return _AppControlImpl::CreateN(soName, *pAppId, *pOperation, L"", _APPCONTROL_PROPERTY_PUBLIC | _APPCONTROL_PROPERTY_SLP);
}
-AppControl*
-_AppControlRegistry::GetNativeAppControlN(const String& aId, const String& oId) const
-{
- std::unique_ptr< IEnumeratorT<AppControl*> > pEnum(__nativeList.GetEnumeratorN());
-
- while (pEnum->MoveNext() == E_SUCCESS)
- {
- AppControl* pAc = null;
- pEnum->GetCurrent(pAc);
-
- if (pAc->GetAppControlProviderId() == aId && pAc->GetOperationId() == oId)
- {
- SysLog(NID_APP, "Found matching AppControl (%ls, %ls)", aId.GetPointer(), oId.GetPointer());
- return _AppControlImpl::CreateN(*pAc);
- }
- }
-
- SysLog(NID_APP, "No matching AppControl (%ls, %ls)", aId.GetPointer(), oId.GetPointer());
-
- return null;
-}
-
//
-// data structure for _AppControlRegistry::GetAppControlListN() only
-//
+// data structure for _AppControlRegistry::FindAppControlListN() only
+//
struct AppSvcIterData
{
public:
};
//
-// callback function for _AppControlRegistry::GetAppControlListN()
+// callback function for _AppControlRegistry::FindAppControlListN()
//
static int
AppSvcIterFnCb(const char* pAppId, void* pData)
return null;
}
+
const _AppControlRegistry::_AppControlAliasEntry*
_AppControlRegistry::GetReverseAppControlAliasEntry(const String& aId, const String& oId) const
{
return null;
}
-AppControl*
-_AppControlRegistry::GetAliasAppControlN(const String& aId, const String& oId) const
+
+const _AppControlRegistry::_AppControlAliasEntry*
+_AppControlRegistry::GetReverseRuntimeAliasEntry(const String& aId, const String& oId) const
{
- const _AppControlAliasEntry* pEntry = GetAppControlAliasEntry(aId, oId);
+ std::unique_ptr< IEnumeratorT<_AppControlAliasEntry*> > pEnum(__runtimeAlias.GetEnumeratorN());
- if (pEntry)
+ while (pEnum->MoveNext() == E_SUCCESS)
{
- AppControl* pAc = GetNativeAppControlN(pEntry->provider2, pEntry->operation2);
- if (pAc)
- {
- _AppControlImpl* pImpl = _AppControlImpl::GetInstance(*pAc);
- pImpl->SetProperty(_APPCONTROL_PROPERTY_ALIAS);
- }
- else
+ _AppControlAliasEntry* pEntry = null;
+ pEnum->GetCurrent(pEntry);
+ if (pEntry->provider2 == aId && pEntry->operation2 == oId)
{
- pAc = GetAppControlN(pEntry->provider2, pEntry->operation2);
- if (pAc)
- {
- _AppControlImpl* pImpl = _AppControlImpl::GetInstance(*pAc);
- pImpl->SetProperty(_APPCONTROL_PROPERTY_ALIAS);
- }
- else
- {
- SysLog(NID_APP, "No matching AppControl found.");
- }
- }
+ SysLog(NID_APP, "Found matching AppControl (%ls, %ls)->(%ls, %ls)", aId.GetPointer(), oId.GetPointer(), pEntry->provider2.GetPointer(), pEntry->operation2.GetPointer());
- return pAc;
+ return pEntry;
+ }
}
- SysLog(NID_APP, "No matching AppControl found.");
return null;
}
+
AppControl*
_AppControlRegistry::GetAppControlN(const String& appId, const String& operationId) const
{
return L"";
}
+
} } // Tizen::App
const Tizen::Base::String operation2;
};
- typedef Tizen::Base::Collection::ArrayListT<AppControl*> AppControlList;
+ typedef Tizen::Base::Collection::ArrayListT<_AppControlAliasEntry*> RuntimeAliasType;
typedef Tizen::Base::Collection::MultiHashMapT<Tizen::Base::String, _AppControlAliasEntry*> AppControlAliasList;
typedef Tizen::Base::Collection::HashMapT<Tizen::Base::String, Tizen::Base::String> AliasMapType;
static _AppControlRegistry* GetInstance(void);
- AppControl* GetTizenAppControlN(const Tizen::Base::String& aId, const Tizen::Base::String& oId) const;
-
- AppControl* GetNativeAppControlN(const Tizen::Base::String& aId, const Tizen::Base::String& oId) const;
-
- AppControl* GetSlpAppControlN(const Tizen::Base::String& packageName, const Tizen::Base::String& oId) const;
-
- AppControl* GetAliasAppControlN(const Tizen::Base::String& aId, const Tizen::Base::String& oId) const;
+ AppControl* GetTizenAppControlN(const Tizen::Base::String& aId, const Tizen::Base::String& oId);
AppControl* GetAppControlN(const Tizen::Base::String& appId, const Tizen::Base::String& operationId) const;
const _AppControlAliasEntry* GetReverseAppControlAliasEntry(const Tizen::Base::String& aId, const Tizen::Base::String& oId) const;
+ const _AppControlAliasEntry* GetReverseRuntimeAliasEntry(const Tizen::Base::String& aId, const Tizen::Base::String& oId) const;
+
AppId GetAliasAppId(const AppId& appId) const;
AppId GetReverseAliasAppId(const AppId& appId) const;
_AppControlRegistry& operator =(const _AppControlRegistry& rhs);
- result LoadRegistry(void);
-
result LoadTizenAppControlRegistry(void);
result LoadLegacyList(void);
Tizen::Base::String GetTizenAppControlProvider(const Tizen::Base::String& appId, const Tizen::Base::String& opId) const;
private:
- AppControlList __nativeList;
-
AliasMapType __tizenList;
AppControlAliasList __aliasList;
AliasMapType __aliasAppId;
+ RuntimeAliasType __runtimeAlias;
+
static _AppControlRegistry* __pSelf;
}; // _AppControlRegistry
AppControl* pAc = null;
- /*
pAc = pRegs->GetTizenAppControlN(aId, oId);
if (pAc != null)
{
SetLastResult(E_SUCCESS);
return pAc;
}
- */
-
- pAc = pRegs->GetNativeAppControlN(aId, oId);
- if (pAc != null)
- {
- SetLastResult(E_SUCCESS);
- return pAc;
- }
-
- pAc = pRegs->GetAliasAppControlN(aId, oId);
- if (pAc != null)
- {
- SetLastResult(E_SUCCESS);
- return pAc;
- }
pAc = pRegs->GetAppControlN(aId, oId);
int ret = aul_app_get_appid_bypid(pid, appId, sizeof(appId));
if (ret != AUL_R_OK)
{
- SysLogException(NID_APP, E_SYSTEM, "Cannot acquire appId.");
+ SysLogException(NID_APP, E_SYSTEM, "Cannot acquire appId for %d.", pid);
return -1;
}
result r = pImpl->__map.GetValue(pid, tmp);
if (r != E_SUCCESS)
{
- SysLogException(NID_APP, E_SYSTEM, "Cannot acquire appId from pid %d.", pid);
+ SysLog(NID_APP, "Cannot acquire appId from pid %d.", pid);
return -1;
}
+ pImpl->__map.Remove(pid);
+
std::unique_ptr< IEnumeratorT<_IAppEventListener*> > pEnum(pImpl->__pEventList->GetEnumeratorN());
if (pEnum.get())
{
}
result
+_AppMessageImpl::RemoveData(const String& key)
+{
+ SysAssert(__pBundle != NULL);
+
+ return RemoveData(__pBundle, key);
+}
+
+result
+_AppMessageImpl::RemoveData(bundle* pBundle, const String& key)
+{
+ std::unique_ptr<char[]> pKey(_StringConverter::CopyToCharArrayN(key));
+
+ bundle_del(pBundle, pKey.get());
+
+ return E_SUCCESS;
+}
+
+result
_AppMessageImpl::SetOperation(bundle* pBundle, const String& operation)
{
std::unique_ptr<char[]> pVal(_StringConverter::CopyToCharArrayN(operation));
_AppMessageImpl::AddData(pBundle, *pKey, *pVal);
}
}
+ else if (typeid(*pObj) == typeid(const ArrayList))
+ {
+ const ArrayList* pVal = static_cast<const ArrayList*>(pEnum->GetValue());
+ if (pVal)
+ {
+ _AppMessageImpl::AddValueArray(pBundle, *pKey, pVal);
+ }
+ }
}
}
}
ArrayList*
-_AppMessageImpl::GetValueArray(bundle* pBundle, const String& key)
+_AppMessageImpl::GetValueArrayN(bundle* pBundle, const String& key)
{
std::unique_ptr<char[]> pKey(_StringConverter::CopyToCharArrayN(key));
- return GetValueArray(pBundle, pKey.get());
+ return GetValueArrayN(pBundle, pKey.get());
}
ArrayList*
-_AppMessageImpl::GetValueArray(bundle* pBundle, const char* pKey)
+_AppMessageImpl::GetValueArrayN(bundle* pBundle, const char* pKey)
{
int len = 0;
const char** pStrArray = bundle_get_str_array(pBundle, pKey, &len);
const bool isValidAppId = _Aul::IsInstalled(appId);
SysTryReturnResult(NID_APP, isValidAppId, E_APP_NOT_INSTALLED, "The application %ls is not installed", appId.GetPointer());
- result r = E_SUCCESS;
- notification_error_e err = NOTIFICATION_ERROR_NONE;
std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
const notification_type_e notiType = (isOngoing) ? NOTIFICATION_TYPE_ONGOING : NOTIFICATION_TYPE_NOTI;
{
class _AppControlImpl;
+class _AppMessageImpl;
class _SqlDataControlImpl;
class _MapDataControlImpl;
result Construct(const _AppControlImpl& ac, const Tizen::Base::String* pUri, const Tizen::Base::String* pMime, const Tizen::Base::Collection::IMap* pMap);
+ result Construct(const _AppMessageImpl& msg, const Tizen::Base::String& oId, const Tizen::Base::String* pUri, const Tizen::Base::String* pMime);
+
result Construct(const _SqlDataControlImpl& dc, _DataControlRequestType requestType, const Tizen::Base::Collection::IList* pList);
result Construct(const _MapDataControlImpl& dc, _DataControlRequestType requestType, const Tizen::Base::Collection::IList* pList);
static result FillMapFromList(Tizen::Base::Collection::IMap* pMap, const Tizen::Base::Collection::IList* pList);
static result FillLegacyAppControlResult(Tizen::Base::Collection::IList& list, int res, const Tizen::Base::Collection::IMap* pMap, const Tizen::Base::String& aId);
+
+ static result SetArgMap(bundle* pBundle, Tizen::Base::Collection::HashMap* pMap);
+
private:
_AppArg(const _AppArg& value);
static result CreateAppControlArg(bundle* b, const _AppControlImpl& ac, const Tizen::Base::String* pUri, const Tizen::Base::String* pMime, const Tizen::Base::Collection::IMap* pList);
+ static result CreateAppControlArg(bundle* b, const Tizen::Base::String& oId, const Tizen::Base::String* pUri, const Tizen::Base::String* pMime, const Tizen::Base::Collection::IMap* pMap);
+
static result CreateSqlDataControlArg(bundle* b, const _SqlDataControlImpl& dc, _DataControlRequestType requestType, const Tizen::Base::Collection::IList* pList);
static result CreateMapDataControlArg(bundle* b, const _MapDataControlImpl& dc, _DataControlRequestType requestType, const Tizen::Base::Collection::IList* pList);
static result SetArgList(bundle* pBundle, Tizen::Base::Collection::ArrayList* pList);
- static result SetArgMap(bundle* pBundle, Tizen::Base::Collection::HashMap* pList);
-
private:
bundle* __pBundle;
}; // _AppArg
static result AppControlCb(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int reqId);
- Tizen::Base::Collection::ArrayListT<int> __appControlResponseEventList;
-
protected:
const AppControl& _appControl;
int _property;
int _processId;
+private:
+ Tizen::Base::Collection::ArrayListT<int> __appControlResponseEventList;
+
friend class AppControl;
friend class _AppArg;
}; // _AppControlImpl
const _AppArg* FindResultRequest(int reqId) const;
- void FinishAppControl(int reqId, int res, const Tizen::Base::Collection::IMap* pArg);
+ void FinishAppControl(int reqId, int res, Tizen::Base::Collection::IMap* pArg);
result LaunchApp(const AppId& appId, _AppArg* pArg, int req = -1);
+
int Launch(const AppId& appId, _AppArg* pArg, int req = -1);
+ int Launch(const AppId& appId, _AppArg* pArg, AppSvcResFn pCb, void* pData, int req);
+
+ int Launch(const _AppMessageImpl& msg, const AppId& aId, const Tizen::Base::String& oId, const Tizen::Base::String* pUriData, const Tizen::Base::String* pMimeType, AppSvcResFn pCb, void* pData);
+
result LaunchAppImplicit(_AppArg* pArg, int req);
result LaunchPkg(const char* pkg_name, const char* op, const char* mime, const char* uri, AppSvcResFn pCb, void* data);
result LaunchPkg(_AppMessageImpl& msg, const char* pkg_name, const char* op, const char* mime, const char* uri, AppSvcResFn pCb, void* data);
- result LaunchPkg(_AppMessageImpl& msg, const Tizen::Base::String& package, const Tizen::Base::String& opId, const Tizen::Base::String* pUri, const Tizen::Base::String* pMime, AppSvcResFn pCb, void* data);
+ int LaunchPkg(_AppMessageImpl& msg, const AppId& appId, const Tizen::Base::String& opId, const Tizen::Base::String* pUri, const Tizen::Base::String* pMime, AppSvcResFn pCb, void* data);
int Launch(_AppMessageImpl& msg, const char* pkg_name, const char* op, const char* mime, const char* uri, AppSvcResFn pCb, void* data);
+
result LaunchAppWithCondition(const AppId& appId, const Tizen::Base::String& condition, Tizen::Base::Collection::IList* pArgs);
result SendAppControlStartResponse(int req, const char* pValue, const char* pOp);
- static bool IsAllowedAppControl(const wchar_t aTable[][2][64], int count, const Tizen::Base::String& aId, const Tizen::Base::String& oId);
+ static bool IsAllowedAppControl(const char aTable[][2][96], int count, const Tizen::Base::String& aId, const Tizen::Base::String& oId);
static AppId GetAliasAppId(const AppId& appId);
_AppMessageImpl& operator=(const _AppMessageImpl& rhs);
+ const bundle* GetBundle(void) const
+ {
+ return __pBundle;
+ }
+
bundle* GetBundle(void)
{
return __pBundle;
result AddData(const Tizen::Base::Collection::IMap* pMap);
+ result RemoveData(const Tizen::Base::String& key);
+
static result SetOperation(bundle* pBundle, const Tizen::Base::String& operation);
static result SetUri(bundle* pBundle, const Tizen::Base::String& uri);
static result AddData(bundle* pBundle, const Tizen::Base::Collection::IList* pList);
+ static result RemoveData(bundle* pBundle, const Tizen::Base::String& key);
+
static result AddStringMap(bundle* pBundle, const Tizen::Base::Collection::IMap* pMap);
- static Tizen::Base::Collection::ArrayList* GetValueArray(bundle* pBundle, const char* pKey);
- static Tizen::Base::Collection::ArrayList* GetValueArray(bundle* pBundle, const Tizen::Base::String& key);
+ static Tizen::Base::Collection::ArrayList* GetValueArrayN(bundle* pBundle, const char* pKey);
+ static Tizen::Base::Collection::ArrayList* GetValueArrayN(bundle* pBundle, const Tizen::Base::String& key);
static result AddValueArray(bundle* pBundle, const char* pKey, const Tizen::Base::Collection::IList* pList);
static result AddValueArray(bundle* pBundle, const Tizen::Base::String& key, const Tizen::Base::Collection::IList* pList);