${CMAKE_SOURCE_DIR}/src/io/inc
${CMAKE_SOURCE_DIR}/src/system/inc
${CMAKE_SOURCE_DIR}/src/security/inc
+ ${CMAKE_SOURCE_DIR}/src/base/runtime
inc
)
FAppAppSetting.cpp
FApp_AppSettingImpl.cpp
FApp_LongevityManager.cpp
+ FApp_AppControlResponseEvent.cpp
)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_SINGLETON_CLEANUP -fvisibility=hidden")
{
class _AppArg;
+class IAppControlResponseListener;
+
+/**
+ * @enum AppControlResposeType
+ */
+enum _AppControlResponseType
+{
+ _APPCONTROL_RESPONSETYPE_START,
+ _APPCONTROL_RESPONSETYPE_COMPLETE
+};
/**
* @class _AppControlEventArg
Tizen::Base::String __operationId;
}; // _AppControlStartEventArg
+/**
+ * @class _AppControlResponseEventArg
+ * @brief
+ */
+class _AppControlResponseEventArg
+ : public Tizen::Base::Object
+ , public Tizen::Base::Runtime::IEventArg
+{
+public:
+ _AppControlResponseEventArg(IAppControlResponseListener* pResponseListener, _AppControlResponseType type, const AppId& appId, const Tizen::Base::String& operationId, result res, AppCtrlResult appControlResult, const Tizen::Base::Collection::IMap* pExtraData, int reqId)
+ : __pResponseListener(pResponseListener)
+ , __type(type)
+ , __appId(appId)
+ , __operationId(operationId)
+ , __res(res)
+ , __appControlResult(appControlResult)
+ , __pExtraData(pExtraData)
+ , __reqId(reqId)
+ {
+ }
+
+ virtual ~_AppControlResponseEventArg(void)
+ {
+ }
+
+ IAppControlResponseListener* GetListener(void) const
+ {
+ return __pResponseListener;
+ }
+
+ _AppControlResponseType GetType(void) const
+ {
+ return __type;
+ }
+
+ const AppId& GetAppId(void) const
+ {
+ return __appId;
+ }
+
+ const Tizen::Base::String& GetOperationId(void) const
+ {
+ return __operationId;
+ }
+
+ result GetResult(void) const
+ {
+ return __res;
+ }
+
+ AppCtrlResult GetAppControlResult(void) const
+ {
+ return __appControlResult;
+ }
+
+ const Tizen::Base::Collection::IMap* GetExtraData(void) const
+ {
+ return __pExtraData;
+ }
+
+ int GetRequestId(void) const
+ {
+ return __reqId;
+ }
+
+private:
+ _AppControlResponseEventArg(const _AppControlResponseEventArg& rhs);
+
+ _AppControlResponseEventArg& operator =(const _AppControlResponseEventArg& rhs);
+
+private:
+ IAppControlResponseListener* __pResponseListener;
+ _AppControlResponseType __type;
+ const AppId& __appId;
+ const Tizen::Base::String& __operationId;
+ result __res;
+ AppCtrlResult __appControlResult;
+ const Tizen::Base::Collection::IMap* __pExtraData;
+ int __reqId;
+}; // _AppControlEventArg
+
} } // Tizen::App
#endif // _FAPP_INTERNAL_APP_CONTROL_EVENT_ARG_H_
#include "FApp_AppInfo.h"
#include "FAppPkg_PackageManagerImpl.h"
#include "FApp_Aul.h"
+#include "FApp_AppControlEventArg.h"
+#include "FApp_AppControlResponseEvent.h"
+#include "FBaseRt_ThreadImpl.h"
using namespace Tizen::Base;
using namespace Tizen::Base::Collection;
, _property(_APPCONTROL_PROPERTY_NONE)
, _processId(_REQ_ID_INVALID)
{
+ __appControlResponseEventList.Construct();
}
_AppControlImpl::~_AppControlImpl(void)
{
+ IEnumeratorT<int>* pEnum = __appControlResponseEventList.GetEnumeratorN();
+ IMapT<int, _AppControlResponseEvent*>* pResponseEventContainer = null;
+ if(pEnum != null)
+ {
+ pResponseEventContainer = _AppControlManager::GetInstance()->GetAppControlResponseEventContainer();
+ }
+
+ while(pEnum->MoveNext() == E_SUCCESS)
+ {
+ int reqId;
+ pEnum->GetCurrent(reqId);
+ if (pResponseEventContainer != null)
+ {
+ _AppControlResponseEvent* pResponseEvent = null;
+ pResponseEventContainer->GetValue(reqId, pResponseEvent);
+ delete pResponseEvent;
+
+ pResponseEventContainer->Remove(reqId);
+ SysLog(NID_APP, "pResponseEvent gets deleted. reqId(%d)", reqId);
+ }
+ }
+ delete pEnum;
}
AppControl*
result
_AppControlImpl::Start(const IList* pDataList, IAppControlEventListener* pListener)
{
+ SysLog(NID_APP, "Enter");
result r = E_SYSTEM;
if (_property & _APPCONTROL_PROPERTY_SLP)
{
SysLogException(NID_APP, E_SYSTEM, "[E_SYSTEM] Invalid AppControl type(property %d)", _property);
}
+ SysLog(NID_APP, "Exit");
return r;
}
result
_AppControlImpl::Start(const String* pUriData, const String* pDataType, const IMap* pExtraData, IAppControlResponseListener* pListener)
{
+ SysLog(NID_APP, "Enter");
result r = E_SYSTEM;
if (_property & _APPCONTROL_PROPERTY_SLP)
{
SysLogException(NID_APP, E_SYSTEM, "[E_SYSTEM] Invalid AppControl type(property %d)", _property);
}
+ SysLog(NID_APP, "Exit");
return r;
}
_AppControlImpl::FindAndStart(const String& operationId, const String* pUriPattern, const String* pDataType, const String* pCategory, const IMap* pExtraData, IAppControlResponseListener* pListener)
{
// [FIXME] valid argument size checking required
+ SysLog(NID_APP, "Enter");
std::unique_ptr<bundle, BundleDeleter> pBundle(bundle_create());
SysTryReturnResult(NID_APP, pBundle.get(), E_OUT_OF_MEMORY, "Bundle creation failure.");
result
_AppControlImpl::StartOsp(const IList* pDataList, IAppControlEventListener* pListener)
{
+ SysLog(NID_APP, "Enter");
result r = E_SUCCESS;
_AppArg* pArg = new (std::nothrow) _AppArg;
delete pArg;
SysTryReturnResult(NID_APP, _processId >= 0, GetLastResult(), "Launching(%ls) is failed", _path.GetPointer());
}
+ SysLog(NID_APP, "Exit");
return r;
}
result
_AppControlImpl::StartOsp(const String* pUriData, const String* pMimeType, const IMap* pDataList, IAppControlResponseListener* pListener)
{
+ SysLog(NID_APP, "Enter");
result r = E_SUCCESS;
_AppArg* pArg = new (std::nothrow) _AppArg;
_AppControlManager::_RequestGuard reqObj = _AppControlManager::_RequestGuard(*pImpl, pArg, AppControlCb, pListener, _property);
req = reqObj.GetRequestNumber();
+ if (_ThreadImpl::GetCurrentThreadImpl()->GetThreadType() == THREAD_TYPE_EVENT_DRIVEN)
+ {
+ _AppControlResponseEvent* pAppControlResponseEvent = new (std::nothrow) _AppControlResponseEvent();
+ if (pAppControlResponseEvent != null)
+ {
+ r = pAppControlResponseEvent->Construct();
+ SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::Construct() is failed", GetErrorMessage(r));
+
+ r = pAppControlResponseEvent->AddListener(*this, true);
+ SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::AddListener() is failed", GetErrorMessage(r));
+
+ IMapT<int, _AppControlResponseEvent*>* pResponseEventContainer = pImpl->GetAppControlResponseEventContainer();
+ if (pResponseEventContainer != null)
+ {
+ pResponseEventContainer->Add(req, pAppControlResponseEvent);
+ __appControlResponseEventList.Add(req);
+ SysLog(NID_APP, "pResponseEvent gets added. reqId(%d)", req);
+ }
+ }
+ }
+
_processId = pImpl->Launch(_path, pArg, req);
if (_processId < 0)
{
delete pArg;
SysTryReturnResult(NID_APP, _processId >= 0, GetLastResult(), "Launching(%ls) is failed", _path.GetPointer());
}
+ SysLog(NID_APP, "Exit");
return r;
}
result
_AppControlImpl::StartImplicit(bundle* pBundle, const IList* pDataList, IAppControlEventListener* pListener)
{
+ SysLog(NID_APP, "Enter");
result r = E_SUCCESS;
_AppArg* pArg = new (std::nothrow) _AppArg;
}
// [FIXME] launch registration is not working correctly
+ SysLog(NID_APP, "Exit");
CATCH:
return r;
result
_AppControlImpl::StartImplicit(bundle* pBundle, const IMap* pData, IAppControlResponseListener* pListener)
{
+ SysLog(NID_APP, "Enter");
result r = E_SUCCESS;
_AppArg* pArg = new (std::nothrow) _AppArg;
_AppControlManager::_RequestGuard reqObj = _AppControlManager::_RequestGuard(*pImpl, pArg, AppControlCb, pListener, _APPCONTROL_PROPERTY_NONE);
req = reqObj.GetRequestNumber();
+ if (_ThreadImpl::GetCurrentThreadImpl()->GetThreadType() == THREAD_TYPE_EVENT_DRIVEN)
+ {
+ _AppControlResponseEvent* pAppControlResponseEvent = new (std::nothrow) _AppControlResponseEvent();
+
+ if (pAppControlResponseEvent != null)
+ {
+ r = pAppControlResponseEvent->Construct();
+ SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::Construct() is failed", GetErrorMessage(r));
+
+ r = pAppControlResponseEvent->AddListener(*pImpl, true);
+ SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::AddListener() is failed", GetErrorMessage(r));
+
+ IMapT<int, _AppControlResponseEvent*>* pResponseEventContainer = pImpl->GetAppControlResponseEventContainer();
+ if (pResponseEventContainer != null)
+ {
+ pResponseEventContainer->Add(req, pAppControlResponseEvent);
+ SysLog(NID_APP, "pResponseEvent gets added. reqId(%d)", req);
+ }
+ }
+ }
r = pImpl->LaunchAppImplicit(pArg, req);
SysTryCatch(NID_APP, r == E_SUCCESS, reqObj.Invalidate(), r, "[%s] Propagating." , GetErrorMessage(r));
}
r = pImpl->LaunchAppImplicit(pArg, -1);
delete pArg;
}
+ SysLog(NID_APP, "Exit");
// [FIXME] launch registration is not working correctly
}
result
-_AppControlImpl::AppControlCbLegacy(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop)
+_AppControlImpl::AppControlCbLegacy(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int reqId)
{
SysLog(NID_APP, "Result value %d", res);
}
result
-_AppControlImpl::AppControlCb(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop)
+_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 code : 0x%x.", ret);
// proper callback invokation
- pListener->OnAppControlCompleteResponseReceived(provider, oId, ret, pMap.get());
+ _AppControlResponseEvent* pResponseEvent = null;
+ _AppControlManager::GetInstance()->GetAppControlResponseEventContainer()->GetValue(reqId, pResponseEvent);
+
+ if (pResponseEvent != null)
+ {
+ _AppControlResponseEventArg* pResponseEventArg = new (std::nothrow) _AppControlResponseEventArg(pListener, _APPCONTROL_RESPONSETYPE_COMPLETE, provider, oId, E_SUCCESS, ret, pMap.get(), reqId);
+ pResponseEvent->Fire(*pResponseEventArg);
+ SysLog(NID_APP, "OnAppControlCompleteResponseReceived, pResponseEvent is Fired");
+ }
+ else
+ {
+ pListener->OnAppControlCompleteResponseReceived(provider, oId, ret, pMap.get());
+ SysLog(NID_APP, "OnAppControlCompleteResponseReceived, Called");
+ }
return E_SUCCESS;
}
result
_AppControlImpl::StartNative(const IList* pDataList, IAppControlEventListener* pListener)
{
+ SysLog(NID_APP, "Enter");
_InProcessInfo* pInfo = _AppControlManager::GetInstance()->__inAppManager.FindItem(_reqId);
SysTryReturnResult(NID_APP, pInfo == null, E_IN_PROGRESS, "Request ID %d is already in progress.", _reqId);
_reqId = req;
+ SysLog(NID_APP, "Exit");
return E_SUCCESS;
CATCH:
result
_AppControlImpl::StartNative(const String* pUriData, const String* pMimeType, const IMap* pDataList, IAppControlResponseListener* pListener)
{
+ SysLog(NID_APP, "Enter");
_InProcessInfo* pInfo = _AppControlManager::GetInstance()->__inAppManager.FindItem(_reqId);
SysTryReturnResult(NID_APP, pInfo == null, E_IN_PROGRESS, "Request ID %d is already in progress.", _reqId);
{
req = _AppControlManager::GetInstance()->__inAppManager.InsertItem(pItem);
}
+
+ if (_ThreadImpl::GetCurrentThreadImpl()->GetThreadType() == THREAD_TYPE_EVENT_DRIVEN)
+ {
+ _AppControlResponseEvent* pAppControlResponseEvent = new (std::nothrow) _AppControlResponseEvent();
+
+ if (pAppControlResponseEvent != null)
+ {
+ r = pAppControlResponseEvent->Construct();
+ SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::Construct() is failed", GetErrorMessage(r));
+
+ r = pAppControlResponseEvent->AddListener(*this, true);
+ SysTryLog(NID_APP, r == E_SUCCESS, "[%s]_AppControlResponseEvent::AddListener() is failed", GetErrorMessage(r));
+
+ IMapT<int, _AppControlResponseEvent*>* pResponseEventContainer = _AppControlManager::GetInstance()->GetAppControlResponseEventContainer();
+ if (pResponseEventContainer != null)
+ {
+ int responseEventRequestId = RESPONSE_EVENT_REQID_MAGIC + req;
+ pResponseEventContainer->Add(responseEventRequestId, pAppControlResponseEvent);
+ __appControlResponseEventList.Add(responseEventRequestId);
+ SysLog(NID_APP, "pResponseEvent gets added. reqId(%d)", responseEventRequestId);
+ }
+ }
+ }
}
r = InvokeStartAppControl(*pLib, req, _provider, _opId, pUriData, pMimeType, pDataList);
}
_reqId = req;
+ SysLog(NID_APP, "Exit");
return E_SUCCESS;
_AppControlManager::GetInstance()->__listenerList.Add(pListener);
}
+void
+_AppControlImpl::OnAppControlResponseEventReceivedN(const Tizen::Base::Runtime::IEventArg* arg)
+{
+ const _AppControlResponseEventArg* pEventArg = dynamic_cast<const _AppControlResponseEventArg*>(arg);
+
+ if (pEventArg != null)
+ {
+ IAppControlResponseListener* pResponseListener = pEventArg->GetListener();
+
+ if(pResponseListener != null)
+ {
+ if(pEventArg->GetType() == _APPCONTROL_RESPONSETYPE_COMPLETE)
+ {
+ pResponseListener->OnAppControlCompleteResponseReceived(pEventArg->GetAppId(), pEventArg->GetOperationId(), pEventArg->GetAppControlResult(), pEventArg->GetExtraData());
+ SysLog(NID_APP, "OnAppControlCompleteResponseReceived called");
+
+ _AppControlResponseEvent* pResponseEvent = null;
+ _AppControlManager::GetInstance()->GetAppControlResponseEventContainer()->GetValue(pEventArg->GetRequestId(), pResponseEvent);
+ _AppControlManager::GetInstance()->GetAppControlResponseEventContainer()->Remove(pEventArg->GetRequestId());
+ delete pResponseEvent;
+ SysLog(NID_APP, "pResponseEvent gets deleted, reqId(%d)", pEventArg->GetRequestId());
+ }
+ else
+ {
+ SysLog(NID_APP, "Unexpected AppControlResponseType(%d)", pEventArg->GetType());
+ }
+ }
+ else
+ {
+ SysLog(NID_APP, "Invalid ResponseListener");
+ }
+ }
+ else
+ {
+ SysLog(NID_APP, "Invalid AppControl arguments : arg(0x%x)", &arg);
+ }
+
+}
}} //Tizen::App
#include "FAppPkg_PackageInfoImpl.h"
#include "FApp_AppMessageImpl.h"
#include "FApp_AppManagerImpl.h"
+#include "FApp_AppControlResponseEvent.h"
using namespace Tizen::App::Package;
using namespace Tizen::Base;
__appControlEvent.Construct();
__appControlEvent.AddListener(*dynamic_cast<_IAppControlSysEventListener*>(this));
__listenerList.Construct();
+ __pAppControlResponseEventContainer = new (std::nothrow)HashMapT<int, _AppControlResponseEvent*>;
+ __pAppControlResponseEventContainer->Construct();
+ __appControlResponseEventList.Construct();
}
_AppControlManager::~_AppControlManager(void)
{
SysLog(NID_APP, "");
__appControlEvent.RemoveListener(*dynamic_cast<_IAppControlSysEventListener*>(this));
+ IEnumeratorT<int>* pEnum = __appControlResponseEventList.GetEnumeratorN();
+
+ if (pEnum != null)
+ {
+ while(pEnum->MoveNext() == E_SUCCESS)
+ {
+ int reqId;
+ pEnum->GetCurrent(reqId);
+ if (__pAppControlResponseEventContainer != null)
+ {
+ _AppControlResponseEvent* pResponseEvent = null;
+ __pAppControlResponseEventContainer->GetValue(reqId, pResponseEvent);
+ delete pResponseEvent;
+
+ __pAppControlResponseEventContainer->Remove(reqId);
+ SysLog(NID_APP, "pResponseEvent gets deleted. reqId(%d)", reqId);
+ }
+ }
+ }
+ delete __pAppControlResponseEventContainer;
+ delete pEnum;
}
_AppControlManager*
if (pInfo->pUserData && (!__listenerList.Contains(pInfo->pUserData)))
{
- (*pInfo->launchCb)(pInfo->pUserData, pInfo->pArg, pAppArg, static_cast<service_result_e>(res), pInfo->property);
+ (*pInfo->launchCb)(pInfo->pUserData, pInfo->pArg, pAppArg, static_cast<service_result_e>(res), pInfo->property, reqId);
}
}
else
r = E_OPERATION_CANCELED;
}
SysLog(NID_APP, "Invoking callback 0x%x.", pListener);
- pListener->OnAppControlStartResponseReceived(actualAppId, operationId, r);
+
+ _AppControlResponseEvent* pResponseEvent = null;
+ __pAppControlResponseEventContainer->GetValue(reqId, pResponseEvent);
+ SysLog(NID_APP, "StartResponseReceived Request Id(%d), ResponseEvent 0x%x.", reqId, pResponseEvent);
+ if (pResponseEvent != null)
+ {
+ String oId(operationId);
+ _AppControlResponseEventArg* pResponseEventArg = new (std::nothrow) _AppControlResponseEventArg(pListener, _APPCONTROL_RESPONSETYPE_START, actualAppId, oId, r, APP_CTRL_RESULT_SUCCEEDED, null, reqId);
+
+ if (pResponseEventArg != null)
+ {
+ pResponseEvent->Fire(*pResponseEventArg);
+ SysLog(NID_APP, "pResponseEvent is Fired");
+ }
+ }
+ else
+ {
+ pListener->OnAppControlStartResponseReceived(actualAppId, operationId, r);
+ SysLog(NID_APP, "OnAppControlStartResponseReceived called directly");
+ }
}
else
{
IAppControlResponseListener* pListener = dynamic_cast<IAppControlResponseListener*>(pInfo->pListener);
if (pListener && (!__listenerList.Contains(pInfo->pListener)))
{
- SysLog(NID_APP, "OSP_AC OnAppControlCompleteResponseReceived");
- pListener->OnAppControlCompleteResponseReceived(aId, oId, static_cast<AppCtrlResult>(res), pArgs);
+ _AppControlResponseEvent* pResponseEvent = null;
+ int responseEventRequestId = RESPONSE_EVENT_REQID_MAGIC + reqId;
+ __pAppControlResponseEventContainer->GetValue(responseEventRequestId, pResponseEvent);
+
+ if (pResponseEvent != null)
+ {
+ _AppControlResponseEventArg* pResponseEventArg = new (std::nothrow) _AppControlResponseEventArg(pListener, _APPCONTROL_RESPONSETYPE_COMPLETE, aId, oId, E_SUCCESS, static_cast<AppCtrlResult>(res), pArgs, responseEventRequestId);
+ if (pResponseEventArg != null)
+ {
+ pResponseEvent->Fire(*pResponseEventArg);
+ SysLog(NID_APP, "pResponseEvent is Fired");
+ }
+ }
+ else
+ {
+ pListener->OnAppControlCompleteResponseReceived(aId, oId, static_cast<AppCtrlResult>(res), pArgs);
+ SysLog(NID_APP, "OnAppControlCompleteResponseReceived called directly");
+ }
}
else
{
return __appControlEvent.FireAsync(arg);
}
+Tizen::Base::Collection::IMapT<int,_AppControlResponseEvent*>*
+_AppControlManager::GetAppControlResponseEventContainer(void)
+{
+ return __pAppControlResponseEventContainer;
+}
+
+
// generic launch callback
static void
LaunchResultCb(bundle* b, int request_code, appsvc_result_val res, void* data)
void
_AppControlManager::FinishAppControl(int reqId, int res, const IMap* pMap)
{
+ SysLog(NID_APP, "Enter.");
_NativeAppControlEventArg* pArg = new (std::nothrow) _NativeAppControlEventArg(reqId, res, pMap);
SysTryReturnVoidResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Return argument allocation failure.");
SendAppControlEvent(*pArg);
+ SysLog(NID_APP, "Exit.");
}
const _AppArg*
return false;
}
+void
+_AppControlManager::OnAppControlResponseEventReceivedN(const Tizen::Base::Runtime::IEventArg* arg)
+{
+ const _AppControlResponseEventArg* pEventArg = dynamic_cast<const _AppControlResponseEventArg*>(arg);
+
+ if (pEventArg != null)
+ {
+ IAppControlResponseListener* pResponseListener = pEventArg->GetListener();
+
+ if(pResponseListener != null)
+ {
+ if(pEventArg->GetType() == _APPCONTROL_RESPONSETYPE_START)
+ {
+ pResponseListener->OnAppControlStartResponseReceived(pEventArg->GetAppId(), pEventArg->GetOperationId(), pEventArg->GetResult());
+ SysLog(NID_APP, "OnAppControlStartResponseReceived called");
+ }
+ else
+ {
+ pResponseListener->OnAppControlCompleteResponseReceived(pEventArg->GetAppId(), pEventArg->GetOperationId(), pEventArg->GetAppControlResult(), pEventArg->GetExtraData());
+ SysLog(NID_APP, "OnAppControlCompleteResponseReceived called");
+
+ _AppControlResponseEvent* pResponseEvent = null;
+ _AppControlManager::GetInstance()->GetAppControlResponseEventContainer()->GetValue(pEventArg->GetRequestId(), pResponseEvent);
+ _AppControlManager::GetInstance()->GetAppControlResponseEventContainer()->Remove(pEventArg->GetRequestId());
+
+ delete pResponseEvent;
+ SysLog(NID_APP, "pResponseEvent gets deleted, reqId(%d)", pEventArg->GetRequestId());
+ }
+ }
+ else
+ {
+ SysLog(NID_APP, "Invalid ResponseListener");
+ }
+ }
+ else
+ {
+ SysLog(NID_APP, "Invalid AppControl arguments : arg(0x%x)", &arg);
+ }
+}
AppId
_AppControlManager::GetAliasAppId(const AppId& appId)
--- /dev/null
+//
+// Open Service Platform
+// Copyright (c) 2012 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+/**
+ * @file FApp_AppControlResponseEvent.cpp
+ * @brief This is the implementation for the _AppControlResponseEvent.cpp class.
+ */
+
+#include <FBaseSysLog.h>
+
+#include "FApp_AppControlResponseEvent.h"
+#include "FApp_IAppControlResponseEventListener.h"
+
+using namespace Tizen::Base;
+using namespace Tizen::Base::Runtime;
+
+namespace Tizen { namespace App
+{
+
+void
+_AppControlResponseEvent::FireImpl(IEventListener& listener, const IEventArg& arg)
+{
+ _IAppControlResponseEventListener* pListener = dynamic_cast<_IAppControlResponseEventListener*>(&listener);
+
+ if (pListener)
+ {
+ pListener->OnAppControlResponseEventReceivedN(&arg);
+ }
+ else
+ {
+ SysLog(NID_APP, "Invalid AppControl listener : listener(0x%x), arg(0x%x)", pListener, &arg);
+ }
+}
+
+} } // Tizen::App
}
result
-_MapDataControlImpl::MapDataControlCallback(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop)
+_MapDataControlImpl::MapDataControlCallback(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int option)
{
ArrayList* pResultList = null;
String* pResult = null;
result SetMapDataControlResponseListener(IMapDataControlResponseListener* pListener);
- static result MapDataControlCallback(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop);
+ static result MapDataControlCallback(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int option);
private:
_MapDataControlImpl(void);
}
result
-_SqlDataControlImpl::SqlDataControlCallback(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop)
+_SqlDataControlImpl::SqlDataControlCallback(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int option)
{
ArrayList* pResultList = null;
String* pResult = null;
result SetSqlDataControlResponseListener(ISqlDataControlResponseListener* pListener);
- static result SqlDataControlCallback(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop);
+ static result SqlDataControlCallback(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int option);
private:
_SqlDataControlImpl(void);
#include <FAppTypes.h>
#include <FOspConfig.h>
#include <FAppAppControl.h>
+#include <FBaseColArrayListT.h>
#include "FApp_AppManagerImpl.h"
+#include "FApp_IAppControlResponseEventListener.h"
namespace Tizen { namespace Base { class String; } }
namespace Tizen { namespace Base { namespace Collection { class IList; } } }
class _OSP_EXPORT_ _AppControlImpl
: public Tizen::Base::Object
+ , public Tizen::App::_IAppControlResponseEventListener
+ , virtual public Tizen::Base::Runtime::IEventListener
{
public:
/**
_property |= prop;
}
+ virtual void OnAppControlResponseEventReceivedN(const Tizen::Base::Runtime::IEventArg* arg);
private:
_AppControlImpl(const AppControl& value);
static result InvokeStartAppControl(Tizen::Base::Runtime::_LibraryImpl& lib, int req, const Tizen::Base::String& appId, const Tizen::Base::String& oId, const Tizen::Base::Collection::IList* pList);
- static result AppControlCbLegacy(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop);
+ static result AppControlCbLegacy(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int reqId);
- static result AppControlCb(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop);
+ 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;
#include "FApp_AppManagerEvent.h"
#include "FApp_IAppManagerServiceEventListener.h"
#include "FApp_RequestManagerT.h"
+#include "FApp_IAppControlResponseEventListener.h"
namespace Tizen { namespace Base
{
class _IAppManagerEventListener;
class _AppManagerEventArg;
class _AppMessageImpl;
+class _AppControlResponseEvent;
-typedef result (*LaunchCbType)(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop);
+typedef result (*LaunchCbType)(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop, int reqId);
typedef void (*AppSvcResFn)(void* b, int requestCode, service_result_e res, void* data);
// _LaunchInfo handles the launch request from this process
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const long LAUNCH_INFO_MAGIC = 0x494C;
+const int RESPONSE_EVENT_REQID_MAGIC = 65536;
class _LaunchInfo
{
class _OSP_EXPORT_ _AppControlManager
: public Tizen::Base::Object
, public _IAppControlSysEventListener
+ , public _IAppControlResponseEventListener
, virtual public Tizen::Base::Runtime::IEventListener
{
public:
_OSP_LOCAL_ result SendAppControlEvent(Tizen::Base::Runtime::IEventArg& arg);
+ _OSP_LOCAL_ Tizen::Base::Collection::IMapT<int,_AppControlResponseEvent*>* GetAppControlResponseEventContainer(void);
_OSP_LOCAL_ result RegisterRequest(service_s* service, int& req, _AppHandler& handler);
_OSP_LOCAL_ void RemoveResultRequest(int reqId)
void RemoveLaunchRequest(int req);
int GetLaunchRequestCount(void);
+ virtual void OnAppControlResponseEventReceivedN(const Tizen::Base::Runtime::IEventArg* arg);
private:
_OSP_LOCAL_ _AppControlManager(void);
_RequestManagerT<_ResultInfo> __resultManager;
Tizen::Base::Collection::ArrayListT<void*> __listenerList;
+ Tizen::Base::Collection::HashMapT<int, _AppControlResponseEvent*>* __pAppControlResponseEventContainer;
+ Tizen::Base::Collection::ArrayListT<int> __appControlResponseEventList;
//friend class AppManager;
friend class _AppControlImpl;
//friend class _SqlDataControlImpl;
--- /dev/null
+//
+// Open Service Platform
+// Copyright (c) 2012 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+/**
+ * @file FApp_AppControlEvent.h
+ * @brief This is the header file of _AppControlEvent
+ */
+
+#ifndef _FAPP_INTERNAL_APP_CONTROL_RESPONSE_EVENT_H_
+#define _FAPP_INTERNAL_APP_CONTROL_RESPONSE_EVENT_H_
+
+#include <FOspConfig.h>
+#include <FAppTypes.h>
+#include <FBaseRt_Event.h>
+
+namespace Tizen { namespace App
+{
+
+/**
+* @class _AppControlResponseEvent
+* @brief This class contains application control response event
+* @since 1.0
+*/
+class _AppControlResponseEvent
+ : public Tizen::Base::Runtime::_Event
+{
+public:
+ result Construct(void)
+ {
+ return _Event::Initialize();
+ }
+
+protected:
+ void FireImpl(Tizen::Base::Runtime::IEventListener& lstener, const Tizen::Base::Runtime::IEventArg& arg);
+}; // _AppControlResponseEvent
+
+} } // Tizen::App
+
+#endif //_FAPP_INTERNAL_APP_CONTROL_RESPONSE_EVENT_H_
\ No newline at end of file
--- /dev/null
+//
+// Open Service Platform
+// Copyright (c) 2012 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+/**
+ * @file FApp_IAppControlSysEventListener.h
+ * @brief This is the header file of the _IAppControlSysEventListener class.
+ */
+
+#ifndef _FAPP_INTERNAL_IAPP_CONTROL_RESPONSE_EVENT_LISTENER_H_
+#define _FAPP_INTERNAL_IAPP_CONTROL_RESPONSE_EVENT_LISTENER_H_
+
+#include <FOspConfig.h>
+#include <FAppTypes.h>
+#include <FBaseRtIEventListener.h>
+
+namespace Tizen { namespace Base { namespace Collection { class IMap; } } }
+
+namespace Tizen { namespace App
+{
+
+/**
+ * @class _IAppControlResponseEventListener
+ * @brief
+ * @since 2.1
+ */
+class _IAppControlResponseEventListener
+ : virtual public Tizen::Base::Runtime::IEventListener
+{
+public:
+ virtual ~_IAppControlResponseEventListener(void) {}
+
+ virtual void OnAppControlResponseEventReceivedN(const Tizen::Base::Runtime::IEventArg* arg) = 0;
+
+}; // _IAppControlResponseEventListener
+
+} } // Tizen::App
+
+#endif //_FAPP_INTERNAL_IAPP_CONTROL_RESPONSE_EVENT_LISTENER_H_
\ No newline at end of file
projects / platform / framework / native / appfw.git / commitdiff