C++ OCRepresentation::setValue方法代码示例

    // gets the updated representation.
    // Updates the representation with latest internal state before
    // sending out.
    OCRepresentation get()
    {
        m_lightRep.setValue("state", m_state);
        m_lightRep.setValue("power", m_power);

        return m_lightRep;
    }

    /// Constructor
    LightResource()
        :m_power(""), m_lightUri("/a/light") {
        // Initialize representation
        m_lightRep.setUri(m_lightUri);

        m_lightRep.setValue("power", m_power);
    }

    OCRepresentation getLightRepresentation()
    {
        m_lightRep.setValue("state", m_lightState);
        m_lightRep.setValue("color", m_lightColor);

        return m_lightRep;
    }

/*
* Class:     org_iotivity_base_OcRepresentation
* Method:    setValueRepresentation
* Signature: (Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;)V
*/
JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation
(JNIEnv *env, jobject thiz, jstring jKey, jobject jValue)
{
    LOGD("OcRepresentation_setValueRepresentation");
    if (!jKey)
    {
        ThrowOcException(OC_STACK_INVALID_PARAM, "key cannot be null");
        return;
    }
    OCRepresentation *rep = JniOcRepresentation::getOCRepresentationPtr(env, thiz);
    if (!rep)
    {
        return;
    }

    std::string key = env->GetStringUTFChars(jKey, nullptr);

    if (jValue)
    {
        OCRepresentation *value = JniOcRepresentation::getOCRepresentationPtr(env, jValue);
        if (!value)
        {
            return;
        }
        rep->setValue(key, *value);
    }
    else
    {
        rep->setNULL(key);
    }
}

void SensorResource::executeJumpingRule(int heartRate)
{
	std::cout << "Crazy Jumping enable flag: " << m_rr->m_crazyJumping << "current heartRate: " << heartRate << std::endl;
	if (m_rr->m_crazyJumping && m_led.s_active && m_led.s_resource) {
		OCRepresentation ledrep;
		PutCallback p (std::bind(&SensorResource::onPut, this, PH::_1, PH::_2, PH::_3));
		if (heartRate >= m_rr->m_heartRate){
			ledrep.setValue("ledColor", RED);
		} else {
			ledrep.setValue("ledColor", GREEN);

		}

		m_led.s_resource->put(ledrep, QueryParamsMap(), p);
	}
}

OCStackResult OCAccountManager::refreshAccessToken(const std::string& userUuid,
                                                   const std::string& refreshToken,
                                                   PostCallback cloudConnectHandler)
{
    std::string uri = m_host + OC_RSRVD_ACCOUNT_TOKEN_REFRESH_URI;

    OCRepresentation rep;
    rep.setValue(OC_RSRVD_USER_UUID, userUuid);
    rep.setValue(OC_RSRVD_DEVICE_ID, m_deviceID);
    rep.setValue(OC_RSRVD_GRANT_TYPE, OC_RSRVD_GRANT_TYPE_REFRESH_TOKEN);
    rep.setValue(OC_RSRVD_REFRESH_TOKEN, refreshToken);

    return checked_guard(m_clientWrapper.lock(), &IClientWrapper::PostResourceRepresentation,
                         OCDevAddr(), uri, rep, QueryParamsMap(), HeaderOptions(),
                         m_connType, cloudConnectHandler, m_defaultQos);
}

WANIpConnection::ConnectionState WANIpConnection::forceTermination()
{
    unique_lock<mutex> wanIpLock(m_mutex);
    m_connectionState = {"", "", 0};
    OCRepresentation rep;
    rep.setValue("uri", m_resource->uri());
    OCRepresentation attributes;
    attributes.setValue("statusUpdateRequest", string("ForceTermination"));
    rep.setValue("connectionState", attributes);
    m_forceTerminationCB = bind(&WANIpConnection::onForceTermination, this, _1, _2, _3);
    m_resource->post(rep, QueryParamsMap(), m_forceTerminationCB);
    if (m_cv.wait_for(wanIpLock, chrono::seconds(MAX_WAIT_TIME_FOR_BLOCKING_CALL)) == cv_status::timeout)
    {
        cerr << "Remote device failed to respond to the request." << endl;
    }
    return m_connectionState;
}

    /// Constructor
    FanResource() :
        m_speed(10), m_fanUri("/a/fan"), m_resourceHandle(0)
    {
        // Initialize representation
        m_fanRep.setUri(m_fanUri);

        m_fanRep.setValue("speed", m_speed);
    }

    OCRepresentation getRepresentation()
    {
        OCRepresentation rep;

        rep.setValue("level", (int) m_pressure);

        return rep;
    }

void putClientRepresentation(std::shared_ptr<OCResource> resource, string &key, int value)
{
	if(resource)
	{
		OCRepresentation rep;
		std::cout << "Putting representation..."<<std::endl;
		rep.setValue(key, value);
		resource->put(rep, QueryParamsMap(), &onPut);
	}
}

void SensorResource::executeGasRule(int density)
{
	if (m_fan.s_active && m_fan.s_resource) {
		OCRepresentation fanrep;
		PutCallback p (std::bind(&SensorResource::onPut, this, PH::_1, PH::_2, PH::_3));
		if ((density > m_rr->m_density) && (m_fanState == false)) {
			std::cout << "Turning on the fan..."<<std::endl;

			fanrep.setValue("fanstate", std::string("on"));
			m_fan.s_resource->put(fanrep, QueryParamsMap(), p);
		}
		else if ((density <= m_rr->m_density) && (m_fanState == true)) {
			std::cout << "Turning off the fan..."<<std::endl;

			fanrep.setValue("fanstate", std::string("off"));
			m_fan.s_resource->put(fanrep, QueryParamsMap(), p);
		}
	}
}

        void RemoteEnrolleeResource::unprovisionEnrollee()
        {
            if (m_ocResource == nullptr)
            {
                throw ESBadRequestException("Resource is not initialized");
            }

            OCRepresentation provisioningRepresentation;

            provisioningRepresentation.setValue(OC_RSRVD_ES_TNN, "");
            provisioningRepresentation.setValue(OC_RSRVD_ES_CD, "");

            m_ocResource->post(provisioningRepresentation, QueryParamsMap(),
                    std::function<
                            void(const HeaderOptions& headerOptions, const OCRepresentation& rep,
                                    const int eCode) >(
                    std::bind(&RemoteEnrolleeResource::checkProvInformationCb, this,
                    std::placeholders::_1, std::placeholders::_2,
                    std::placeholders::_3)));
        }

OCStackResult OCAccountManager::signInOut(const std::string& userUuid,
                                          const std::string& accessToken,
                                          bool isSignIn,
                                          PostCallback cloudConnectHandler)
{
    std::string uri = m_host + OC_RSRVD_ACCOUNT_SESSION_URI;

    OCRepresentation rep;
    if (isSignIn)
    {
        rep.setValue(OC_RSRVD_USER_UUID, userUuid);
        rep.setValue(OC_RSRVD_DEVICE_ID, m_deviceID);
        rep.setValue(OC_RSRVD_ACCESS_TOKEN, accessToken);
    }
    rep.setValue(OC_RSRVD_LOGIN, isSignIn);

    return checked_guard(m_clientWrapper.lock(), &IClientWrapper::PostResourceRepresentation,
                         OCDevAddr(), uri, rep, QueryParamsMap(), HeaderOptions(),
                         m_connType, cloudConnectHandler, m_defaultQos);
}

void allBulbOff()
{
    OCRepresentation rep;

    rep.setValue("DoAction", std::string("AllBulbOff"));

    if (g_resource)
    {
        g_resource->post("a.collection", GROUP_INTERFACE, rep, QueryParamsMap(),
                &onPost);
    }
}

void SensorResource::onObserve(const HeaderOptions headerOptions, const OCRepresentation& rep,
	const int& eCode, const int& sequenceNumber)
{
	int density = 0;
	int ledColor = 0;
	bool motion = false;
	try
	{
		if(eCode == OC_STACK_OK) {
			if (rep.hasAttribute("density")) {
				m_gas.s_active = true;
				rep.getValue("density", density);
				std::cout << "\tdensity: " << density << std::endl;

				if (m_rr->m_kitchenMonitor) {
					std::cout << "Kitchen Monitor is enabled" << std::endl;
					executeGasRule(density);
				}
			}

			if (rep.hasAttribute("fanstate")) {
				m_fan.s_active = true;
				std::string state = rep.getValue<std::string>("fanstate");
				m_fanState = (state == "on" ? true:false);
				std::cout << "\tfanstate: " << m_fanState << std::endl;
			}

			if (rep.hasAttribute("ledColor")) {
				m_led.s_active = true;
				rep.getValue("ledColor", ledColor);
				std::cout << "\tledColor: " << ledColor << std::endl;
			}
			if (rep.hasAttribute("motion")) {
				m_pri.s_active = true;
				rep.getValue("motion", motion);
				std::cout << "\tmotion: " << motion << std::endl;
				PutCallback p (std::bind(&SensorResource::onPut, this, PH::_1, PH::_2, PH::_3));
				if ((motion == true) && (m_led.s_active == true)) {
					OCRepresentation ledrep;
					ledrep.setValue("ledColor", BLUE);
					m_led.s_resource->put(ledrep, QueryParamsMap(), p);
				}
			}
		}
		else {
			std::cout << "onObserve Response error: " << eCode << std::endl;
		}
	}
	catch(std::exception& e) {
		std::cout << "Exception: " << e.what() << " in onObserve" << std::endl;
	}
}