import org.iotivity.ca.CaInterface;
import org.iotivity.base.BuildConfig;
+import org.iotivity.base.OcProvisioning;
+import org.iotivity.base.OcException;
import java.util.EnumSet;
import java.util.Iterator;
* @param platformConfig platform configuration
*/
public synchronized static void Configure(PlatformConfig platformConfig) {
- if (sIsStopPlatform)
- {
- OcPlatform.start();
- sIsStopPlatform = false;
- }
-
if (!sIsPlatformInitialized) {
CaInterface.initialize(platformConfig.getActivity(), platformConfig.getContext());
platformConfig.getAvailableTransportType()
);
+ if (platformConfig.getUuidSeedSize() > 0) {
+ try {
+ OcProvisioning.setDeviceIdSeed(platformConfig.getUuidSeed());
+ } catch (OcException e) {
+ // Do nothing.
+ }
+ }
+
sIsPlatformInitialized = true;
}
+
+ if (sIsStopPlatform)
+ {
+ OcPlatform.start();
+ sIsStopPlatform = false;
+ }
}
private static native void configure(int serviceType,
private int mKeySize;
private byte[] mKey;
private int mTransportType;
+ private byte[] mUuidSeed;
+ private int mUuidSeedSize;
+
/**
* @param activity app activity
* @param context app context
* specify port
* @param qualityOfService quality of service
* @param dbPath Persistant storage file for SVR Database.
+ * @param uuidSeed byte array of seed value for gernerating UUID.
+ * @param uuidSeedSize length of seed
*/
public PlatformConfig(Activity activity,
Context context,
String ipAddress,
int port,
QualityOfService qualityOfService,
- String dbPath) {
+ String dbPath,
+ byte[] seed,
+ int seedSize) {
this.mActivity=activity;
this.mContext = context;
this.mServiceType = serviceType;
this.mQualityOfService = qualityOfService;
this.mSvrDbPath = dbPath;
this.mTransportType = 0;
+ this.mUuidSeed = seed;
+ this.mUuidSeedSize = seedSize;
}
public PlatformConfig(Context context,
this.mKey = key;
this.mTransportType = 0;
}
+
/**
* @param context app context
* @param serviceType indicate IN_PROC or OUT_OF_PROC
int port,
QualityOfService qualityOfService,
String dbPath) {
- this(null,context,serviceType,modeType,ipAddress,port,qualityOfService, dbPath);
+ this(null,context,serviceType,modeType,ipAddress,port,qualityOfService, dbPath, null, 0);
+ }
+
+ /**
+ * @param context app context
+ * @param serviceType indicate IN_PROC or OUT_OF_PROC
+ * @param modeType indicate whether we want to do server, client or both
+ * @param ipAddress ip address of server
+ * if you specify 0.0.0.0 : it listens on any interface
+ * @param port port of server
+ * if you specifiy 0 : next available random port is used
+ * if you specify 5683 : client discovery can work even if they don't
+ * specify port
+ * @param qualityOfService quality of service
+ * @param dbPath Persistant storage file for SVR Database.
+ * @param uuidSeed byte array of seed value for gernerating UUID.
+ * @param uuidSeedSize length of seed
+ */
+ public PlatformConfig(Context context,
+ ServiceType serviceType,
+ ModeType modeType,
+ String ipAddress,
+ int port,
+ QualityOfService qualityOfService,
+ String dbPath,
+ byte[] uuidSeed,
+ int uuidSeedSize) {
+ this(null,context,serviceType,modeType,ipAddress,port,qualityOfService, dbPath, uuidSeed, uuidSeedSize);
}
/**
String ipAddress,
int port,
QualityOfService qualityOfService) {
- this(null,context,serviceType,modeType,ipAddress,port,qualityOfService, "");
+ this(null,context,serviceType,modeType,ipAddress,port,qualityOfService, "", null, 0);
}
/**
String ipAddress,
int port,
QualityOfService qualityOfService) {
- this(activity,context,serviceType,modeType,ipAddress,port,qualityOfService, "");
+ this(activity,context,serviceType,modeType,ipAddress,port,qualityOfService, "", null, 0);
}
public Context getContext() {
return mContext;
public int getAvailableTransportType() {
return mTransportType;
}
+
+ public byte[] getUuidSeed()
+ {
+ return mUuidSeed;
+ }
+
+ public int getUuidSeedSize()
+ {
+ return mUuidSeedSize;
+ }
}
caLeScanCallback(device);
} else if(uuid.toString().contains(CUSTOM_UUID.toLowerCase()) ||
uuid.toString().contains(CUSTOM_UUID2.toLowerCase())) {
- Log.d(TAG, "we found that has the Device [" + device.getAddress() +
- "] which has custom adv");
+ Log.d(TAG, "Found device which has custom adv");
caLeScanCallback(device);
}
}
}
CALogAdapterTypeInfo(adapter);
- OIC_LOG_V(INFO, ANALYZER_TAG, "Address = [%s]:[%d]", addr, port);
+ OIC_LOG_V(DEBUG, ANALYZER_TAG, "Address = [%s]:[%d]", addr, port);
OIC_LOG(DEBUG, ANALYZER_TAG, "=================================================");
// samsung log
OC_HIGH_QOS,
/** No Quality is defined, let the stack decide.*/
- OC_NA_QOS
+ OC_NA_QOS,
+
+ OC_LOW_QOS_WITH_TCP
} OCQualityOfService;
/**
CopyDevAddrToEndpoint(clientCB->devAddr, &endpoint);
- if ((endpoint.adapter & CA_ADAPTER_IP) && qos != OC_HIGH_QOS)
+ if (((endpoint.adapter & CA_ADAPTER_IP) && qos != OC_HIGH_QOS) ||
+ ((endpoint.adapter & CA_ADAPTER_TCP) && OC_LOW_QOS_WITH_TCP == qos))
{
+ OIC_LOG_V(INFO, TAG, "the %s observe callback is removed", clientCB->requestUri);
FindAndDeleteClientCB(clientCB);
break;
}
HighQos = OC_HIGH_QOS,
/** No Quality is defined, let the stack decide. */
- NaQos = OC_NA_QOS
+ NaQos = OC_NA_QOS,
+
+ LowQosWithTcp = OC_LOW_QOS_WITH_TCP
};
/**
#define SC_RSRVD_ES_VENDOR_UTC_DATE_TIME "x.com.samsung.datetime"
#define SC_RSRVD_ES_VENDOR_REGIONAL_DATE_TIME "x.com.samsung.regionaldatetime"
#define SC_RSRVD_ES_VENDOR_ES_PROTOCOL_VERSION "x.com.samsung.espv"
+#define SC_RSRVD_ES_VENDOR_TIMEZONE_ID "x.com.samsung.timezoneid"
+#define SC_RSRVD_ES_VENDOR_HIDDEN "x.com.samsung.hidden"
+#define SC_RSRVD_ES_VENDOR_HUB_ID "x.com.samsung.hubid"
#define SC_RSRVD_ES_VENDOR_CANDIDATEAPS "x.com.samsung.candidateaps"
#define SC_RSRVD_ES_VENDOR_SSID "x.com.samsung.ssid"
#define SC_RSRVD_ES_VENDOR_PASSPHRASE "x.com.samsung.passphrase"
{
int discoveryChannel; /**< Wi-Fi AP Channel used for fast discovery **/
char bssid[MAXLEN_STRING]; /**< Wi-Fi bssid information. **/
+ bool isHidden;
int numCandidateAP;
SCCandidateAPInfo candidateAPInfo[MAXNUM_CANDIDATE_AP];
} SCWiFiConfProperties;
char gpsLocation[MAXLEN_STRING]; /**< GPS information of device. Longitude and latitude in json format **/
char utcDateTime[MAXLEN_DATE_TIME]; /**< UTC date time **/
char regionalDateTime[MAXLEN_DATE_TIME]; /**< Regional date time **/
+ char timeZoneId[MAXLEN_STRING]; /** Name of Time Zone **/
+ char hubId[MAXLEN_STRING]; /** HubId of device **/
} SCDevConfProperties;
typedef struct SCCoapCloudServerConfProperties
char utcDateTime[MAXLEN_DATE_TIME]; /**< UTC date time **/
char regionalDateTime[MAXLEN_DATE_TIME]; /**< Regional date time **/
char esProtocolVersion[MAXLEN_STRING]; /**< Samsung Easy Setup Protocol Version **/
+ char timeZoneId[MAXLEN_STRING];
+ bool isHidden;
+ char hubId[MAXLEN_STRING]; /**< HubId of device **/
int numCandidateAP;
SCCandidateAPInfo candidateAPInfo[MAXNUM_CANDIDATE_AP];
} SCProperties;
{
int64_t channel = -1;
char *bssid = NULL;
+ bool isHidden = false;
if (OCRepPayloadGetPropInt(payload, SC_RSRVD_ES_VENDOR_DISCOVERY_CHANNEL, &channel))
{
if(*userdata == NULL)
pWifiConfProp->numCandidateAP = (int)dimensions[0];
g_SCProperties.numCandidateAP = (int)dimensions[0];
}
+
+ if (OCRepPayloadGetPropBool(payload, SC_RSRVD_ES_VENDOR_HIDDEN, &isHidden))
+ {
+ if(*userdata == NULL)
+ {
+ *userdata = (void*)OICMalloc(sizeof(SCWiFiConfProperties));
+ if( *userdata == NULL )
+ {
+ OIC_LOG(ERROR, SC_ENROLLEE_TAG, "OICMalloc for SCWiFiConfProperties is failed");
+ return ;
+ }
+ memset(*userdata, 0, sizeof(SCWiFiConfProperties));
+ }
+ OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "[User specific property] %s : %d",
+ SC_RSRVD_ES_VENDOR_HIDDEN, isHidden);
+ ((SCWiFiConfProperties*)(*userdata))->isHidden = isHidden;
+ g_SCProperties.isHidden = isHidden;
+ }
}
else if(strstr(resourceType, OC_RSRVD_ES_RES_TYPE_DEVCONF))
{
OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.regionalDateTime %s", g_SCProperties.regionalDateTime);
}
+ char *timeZoneId = NULL;
+ if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_TIMEZONE_ID, &timeZoneId))
+ {
+ OICStrcpy(pDevConfProp->timeZoneId, strlen(timeZoneId)+1, timeZoneId);
+ OICStrcpy(g_SCProperties.timeZoneId, strlen(timeZoneId)+1, timeZoneId);
+ OIC_LOG_V(INFO_PRIVATE, SC_ENROLLEE_TAG, "pDevConfProp.timeZoneId %s", g_SCProperties.timeZoneId);
+ }
+
char *ssoList = NULL;
if (OCRepPayloadGetPropString(payload, SC_RSRVD_ES_VENDOR_SSO_LIST, &ssoList))
{
OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_UTC_DATE_TIME, g_SCProperties.utcDateTime);
OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_REGIONAL_DATE_TIME, g_SCProperties.regionalDateTime);
OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_ES_PROTOCOL_VERSION, g_SCProperties.esProtocolVersion);
+ OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_HUB_ID, g_SCProperties.hubId);
#else
if(g_SCProperties.deviceType != NULL)
{
{
OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_ES_PROTOCOL_VERSION, g_SCProperties.esProtocolVersion);
}
+ if (g_SCProperties.hubId != NULL)
+ {
+ OCRepPayloadSetPropString(payload, SC_RSRVD_ES_VENDOR_HUB_ID, g_SCProperties.hubId);
+ }
#endif
}
}
NONE_AUTH = 0, /**< NO authentication **/
WEP, /**< WEP **/
WPA_PSK, /**< WPA-PSK **/
- WPA2_PSK /**< WPA2-PSK **/
+ WPA2_PSK, /**< WPA2-PSK **/
+ FT_PSK /**< FT-PSK **/
} WIFI_AUTHTYPE;
/**
NONE_AUTH(0),
WEP(1),
WPA_PSK(2),
- WPA2_PSK(3);
+ WPA2_PSK(3),
+ FT_PSK(4);
private int value;
#define SC_RSRVD_ES_VENDOR_ACCOUNT "x.com.samsung.account"
#define SC_RSRVD_ES_VENDOR_SSO_LIST "x.com.samsung.ssolist"
#define SC_RSRVD_ES_VENDOR_ADDITIONAL_AUTH_CODE "x.com.samsung.aac"
+#define SC_RSRVD_ES_VENDOR_SA_API_SERVER "x.com.samsung.saapiserver"
+#define SC_RSRVD_ES_VENDOR_SA_AUTH_SERVER "x.com.samsung.saauthserver"
+#define SC_RSRVD_ES_VENDOR_SA_DEVICE_SECURITY_CODE "x.com.samsung.sadsc"
#define SC_RSRVD_ES_VENDOR_ACCESS_TOKEN "x.com.samsung.accesstoken"
#define SC_RSRVD_ES_VENDOR_REFRESH_TOKEN "x.com.samsung.refreshtoken"
#define SC_RSRVD_ES_VENDOR_UTC_DATE_TIME "x.com.samsung.datetime"
#define SC_RSRVD_ES_VENDOR_COUNTRY "x.com.samsung.country"
#define SC_RSRVD_ES_VENDOR_GPSLOCATION "x.com.samsung.gpslocation"
#define SC_RSRVD_ES_VENDOR_ES_PROTOCOL_VERSION "x.com.samsung.espv"
+#define SC_RSRVD_ES_VENDOR_MODEL_NUMBER_OLD "mnmo"
+#define SC_RSRVD_ES_VENDOR_LANGUAGE_OLD "lang"
+#define SC_RSRVD_ES_VENDOR_COUNTRY_OLD "ctry"
+#define SC_RSRVD_ES_VENDOR_GPSLOCATION_OLD "loc"
+#define SC_RSRVD_ES_VENDOR_SERVER_ID "x.com.samsung.serverid"
+#define SC_RSRVD_ES_VENDOR_TIMEZONE_ID "x.com.samsung.timezoneid"
+#define SC_RSRVD_ES_VENDOR_HIDDEN "x.com.samsung.hidden"
+#define SC_RSRVD_ES_VENDOR_HUB_ID "x.com.samsung.hubid"
+#define SC_RSRVD_ES_VENDOR_SERVER_DEPLOYMENT_ENVIRONMENT "x.com.samsung.deployenv"
#define SC_RSRVD_ES_VENDOR_CANDIDATEAPS "x.com.samsung.candidateaps"
#define SC_RSRVD_ES_VENDOR_SSID "x.com.samsung.ssid"
#define SC_RSRVD_ES_VENDOR_PASSPHRASE "x.com.samsung.passphrase"
m_rep.setValue(SC_RSRVD_ES_VENDOR_LANGUAGE, language);
m_rep.setValue(SC_RSRVD_ES_VENDOR_COUNTRY, country);
m_rep.setValue(SC_RSRVD_ES_VENDOR_GPSLOCATION, location);
+
+ /* [CONPRO-888] Support backward compatibility */
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_LANGUAGE_OLD, language);
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_COUNTRY_OLD, country);
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_GPSLOCATION_OLD, location);
}
/**
{
return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_LANGUAGE);
}
+ else if(m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_LANGUAGE_OLD))
+ {
+ return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_LANGUAGE_OLD);
+ }
return std::string("");
}
{
return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_COUNTRY);
}
+ else if(m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_COUNTRY_OLD))
+ {
+ return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_COUNTRY_OLD);
+ }
return std::string("");
}
{
return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_GPSLOCATION);
}
+ else if(m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_GPSLOCATION_OLD))
+ {
+ return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_GPSLOCATION_OLD);
+ }
return std::string("");
}
}
return {};
}
+
+ /**
+ * Set time zone for location based services when easy-setup is done
+ *
+ * @param Name of timeZone
+ */
+ void setTimeZoneId(const std::string &timeZoneId)
+ {
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_TIMEZONE_ID, timeZoneId);
+ }
+
+ /**
+ * Get the Name of TimeZone
+ *
+ * @return Name of timeZone
+ */
+ std::string getTimeZoneId()
+ {
+ if (m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_TIMEZONE_ID))
+ {
+ return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_TIMEZONE_ID);
+ }
+ return {};
+ }
+
+ /**
+ * Sets the hidden property of wifi
+ * if the Value is true, wifi is a hidden wifi, otherwise it is not
+ *
+ * @param isHidden: value indicating whether the wifi is hidden or not
+ */
+ void setHiddenProperty(bool isHidden)
+ {
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_HIDDEN, isHidden);
+ }
+
+ /**
+ * Gets the property of the wifi whether it is hidden or not
+ *
+ * @return hidden value indicating whether the wifi is hidden or not
+ */
+ bool getHiddenProperty()
+ {
+ if (m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_HIDDEN))
+ {
+ return m_rep.getValue<bool>(SC_RSRVD_ES_VENDOR_HIDDEN);
+ }
+ return false;
+ }
};
class SCCloudProp : public CloudProp
}
/**
+ * Set samsung-specific additional Api provider to be delivered to Enrollee (for devices(TV/AV, Lux) sign up SSO)
+ *
+ * @param additionalApiProvider - additional Api Provider
+ */
+ void setAdditionalApiProvider(const std::string &additionalApiProvider)
+ {
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_SA_API_SERVER, additionalApiProvider);
+ }
+
+ /**
+ * Get samsung-specific additional Api provider (for devices(TV/AV, Lux) sign up SSO)
+ *
+ * @return additionalApiProvider - additional Api Provider
+ */
+ std::string getAdditionalApiProvider()
+ {
+ if(m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_SA_API_SERVER))
+ {
+ return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_SA_API_SERVER);
+ }
+ return {};
+ }
+
+ /**
+ * Set samsung-specific additional Auth provider to be delivered to Enrollee (for devices(TV/AV, Lux) sign up SSO)
+ *
+ * @param additionalAuthProvider - additional Auth Provider
+ */
+ void setAdditionalAuthProvider(const std::string &additionalAuthProvider)
+ {
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_SA_AUTH_SERVER, additionalAuthProvider);
+ }
+
+ /**
+ * Get samsung-specific additional Auth provider (for devices(TV/AV, Lux) sign up SSO)
+ *
+ * @return additionalAuthProvider - additional Auth Provider
+ */
+ std::string getAdditionalAuthProvider()
+ {
+ if(m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_SA_AUTH_SERVER))
+ {
+ return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_SA_AUTH_SERVER);
+ }
+ return {};
+ }
+
+ /**
+ * Set samsung-specific additional device security code to be delivered to Enrollee (for devices(TV/AV, Lux) sign up SSO)
+ *
+ * @param additionalDeviceSecCode - additional DeviceSecurityCode (for devices(TV/AV, Lux) sign up VD SSO)
+ */
+ void setAdditionalDeviceSecCode(const std::string &additionalDeviceSecCode)
+ {
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_SA_DEVICE_SECURITY_CODE, additionalDeviceSecCode);
+ }
+
+ /**
+ * Get samsung-specific additional device security code
+ *
+ * @return additionalDeviceSecCode - additional DeviceSecurityCode
+ */
+ std::string getAdditionalDeviceSecCode()
+ {
+ if(m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_SA_DEVICE_SECURITY_CODE))
+ {
+ return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_SA_DEVICE_SECURITY_CODE);
+ }
+ return {};
+ }
+
+ /**
+ * Set current deployment environment which IoT Server is operating such as "PRD" "STG"
+ *
+ * @param serverDeploymentEnv - current server Deployment Environment
+ */
+ void setServerDeploymentEnv(const std::string &serverDeploymentEnv)
+ {
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_SERVER_DEPLOYMENT_ENVIRONMENT, serverDeploymentEnv);
+ }
+
+ /**
+ * Get current server deployment environment which IoT Server is operating such as "PRD", "STG" etc
+ *
+ * @return serverDeploymentEnv - current server deployment environment
+ */
+ std::string getServerDeploymentEnv()
+ {
+ if (m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_SERVER_DEPLOYMENT_ENVIRONMENT))
+ {
+ return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_SERVER_DEPLOYMENT_ENVIRONMENT);
+ }
+ return {};
+ }
+
+ /**
* Set samsung-specific refresh token property to be delivered to Enrollee
*
* @param refreshtoken - Refresh token.
}
return {};
}
+
+ /**
+ * Set samsung-specific client service ID property to be delivered to Enrollee
+ *
+ * @param clientID - Client service ID
+ */
+ void setServerId(const std::string &serverId)
+ {
+ m_rep.setValue(SC_RSRVD_ES_VENDOR_SERVER_ID, serverId);
+ }
+
+ /**
+ * Get samsung-specific client service ID property.
+ *
+ * @return Client service ID.
+ */
+ std::string getServerId()
+ {
+ if(m_rep.hasAttribute(SC_RSRVD_ES_VENDOR_SERVER_ID))
+ {
+ return m_rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_SERVER_ID);
+ }
+ return {};
+ }
};
/**
{
return rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_MODEL_NUMBER);
}
+ else if(rep.hasAttribute(SC_RSRVD_ES_VENDOR_MODEL_NUMBER_OLD))
+ {
+ return rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_MODEL_NUMBER_OLD);
+ }
}
}
return std::string("");
return std::string("");
}
+ /**
+ * Gets the ISO country code of the device
+ * (ISO 3166-1 Alpha-2)
+ *
+ * @return the ISO Country code of the device
+ */
+ std::string getCountry() const
+ {
+ std::vector<OCRepresentation> children = m_EasySetupRep.getChildren();
+ for(auto child = children.begin(); child != children.end(); ++child)
+ {
+ if(child->getUri().find(OC_RSRVD_ES_URI_DEVCONF) != std::string::npos)
+ {
+ OCRepresentation rep;
+ if(child->hasAttribute(OC_RSRVD_REPRESENTATION))
+ {
+ rep = child->getValue<OCRepresentation>(OC_RSRVD_REPRESENTATION);
+ }
+ else
+ {
+ return std::string("");
+ }
+
+ if(rep.hasAttribute(SC_RSRVD_ES_VENDOR_COUNTRY))
+ {
+ return rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_COUNTRY);
+ }
+ }
+ }
+ return std::string("");
+ }
+
+ /**
+ * Gets the HubId of the device
+ *
+ * @return hubId of the device
+ */
+ std::string getHubId() const
+ {
+ std::vector<OCRepresentation> children = m_EasySetupRep.getChildren();
+ for(auto child = children.begin(); child != children.end(); ++child)
+ {
+ if(child->getUri().find(OC_RSRVD_ES_URI_DEVCONF) != std::string::npos)
+ {
+ OCRepresentation rep;
+ if(child->hasAttribute(OC_RSRVD_REPRESENTATION))
+ {
+ rep = child->getValue<OCRepresentation>(OC_RSRVD_REPRESENTATION);
+ }
+ else
+ {
+ return std::string("");
+ }
+
+ if(rep.hasAttribute(SC_RSRVD_ES_VENDOR_HUB_ID))
+ {
+ return rep.getValue<std::string>(SC_RSRVD_ES_VENDOR_HUB_ID);
+ }
+ }
+ }
+ return std::string("");
+ }
+
};
}
}
static std::unique_ptr<std::list<DataCachePtr>> s_cacheDataList;
std::map<CacheID, DataCachePtr> cacheIDmap;
- std::list<ObserveCache::Ptr> m_observeCacheList;
std::map<CacheID, ObserveCache::Ptr> observeCacheIDmap;
ResourceCacheManager() = default;
auto newHandler = std::make_shared<ObserveCache>(pResource);
newHandler->startCache(std::move(func));
- m_observeCacheList.push_back(newHandler);
observeCacheIDmap.insert(std::make_pair(retID, newHandler));
return retID;
projects / platform / upstream / iotivity.git / commitdiff