Java LwM2mResource类代码示例

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
@Ignore
@Test
public void cannot_create_instance_with_extraneous_resources() throws InterruptedException {
    // create ACL instance
    LwM2mObjectInstance instance = new LwM2mObjectInstance(0, Arrays.<LwM2mResource> asList(
            LwM2mSingleResource.newIntegerResource(3, 123), LwM2mSingleResource.newIntegerResource(50, 123)));
    CreateRequest request = new CreateRequest(2, instance);
    CreateResponse response = helper.server.send(helper.getCurrentRegistration(), request);

    // verify result
    assertEquals(ResponseCode.BAD_REQUEST, response.getCode());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));

    // try to read to check if the instance is not created
    // client registration
    ReadResponse readResponse = helper.server.send(helper.getCurrentRegistration(), new ReadRequest(2, 0));
    assertEquals(ResponseCode.NOT_FOUND, readResponse.getCode());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
@Override
public WriteResponse write(int resourceid, LwM2mResource value) {
    LOG.info("Write on Device Resource " + resourceid + " value " + value);
    switch (resourceid) {
    case 13:
        return WriteResponse.notFound();
    case 14:
        setUtcOffset((String) value.getValue());
        fireResourcesChange(resourceid);
        return WriteResponse.success();
    case 15:
        setTimezone((String) value.getValue());
        fireResourcesChange(resourceid);
        return WriteResponse.success();
    default:
        return super.write(resourceid, value);
    }
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
private LwM2mObjectInstance convertToSecurityInstance(int instanceId, ServerSecurity securityConfig) {
    Collection<LwM2mResource> resources = new ArrayList<>();

    resources.add(LwM2mSingleResource.newStringResource(0, securityConfig.uri));
    resources.add(LwM2mSingleResource.newBooleanResource(1, securityConfig.bootstrapServer));
    resources.add(LwM2mSingleResource.newIntegerResource(2, securityConfig.securityMode.code));
    resources.add(LwM2mSingleResource.newBinaryResource(3, securityConfig.publicKeyOrId));
    resources.add(LwM2mSingleResource.newBinaryResource(4, securityConfig.serverPublicKeyOrId));
    resources.add(LwM2mSingleResource.newBinaryResource(5, securityConfig.secretKey));
    resources.add(LwM2mSingleResource.newIntegerResource(6, securityConfig.smsSecurityMode.code));
    resources.add(LwM2mSingleResource.newBinaryResource(7, securityConfig.smsBindingKeyParam));
    resources.add(LwM2mSingleResource.newBinaryResource(8, securityConfig.smsBindingKeySecret));
    resources.add(LwM2mSingleResource.newStringResource(9, securityConfig.serverSmsNumber));
    resources.add(LwM2mSingleResource.newIntegerResource(10, securityConfig.serverId));
    resources.add(LwM2mSingleResource.newIntegerResource(11, securityConfig.clientOldOffTime));

    return new LwM2mObjectInstance(instanceId, resources);
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
private static LwM2mResource parseResourceTlv(Tlv tlv, int objectId, int objectInstanceId, LwM2mModel model)
        throws InvalidValueException {
    LwM2mPath resourcePath = new LwM2mPath(objectId, objectInstanceId, tlv.getIdentifier());
    Type expectedType = getResourceType(resourcePath, model);
    Integer resourceId = tlv.getIdentifier();
    switch (tlv.getType()) {
    case MULTIPLE_RESOURCE:
        return LwM2mMultipleResource.newResource(resourceId,
                parseTlvValues(tlv.getChildren(), expectedType, resourcePath), expectedType);
    case RESOURCE_VALUE:
        return LwM2mSingleResource.newResource(resourceId,
                parseTlvValue(tlv.getValue(), expectedType, resourcePath), expectedType);
    default:
        throw new InvalidValueException("Invalid TLV value", resourcePath);
    }
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
@Override
public void visit(LwM2mObject object) {
    LOG.trace("Encoding Object {} into JSON", object);
    // Validate request path
    if (!requestPath.isObject()) {
        throw new IllegalArgumentException("Invalid request path for JSON object encoding");
    }

    // Create resources
    resourceList = new ArrayList<>();
    for (LwM2mObjectInstance instance : object.getInstances().values()) {
        for (LwM2mResource resource : instance.getResources().values()) {
            String prefixPath = Integer.toString(instance.getId()) + "/" + Integer.toString(resource.getId());
            resourceList.addAll(lwM2mResourceToJsonArrayEntry(prefixPath, timestamp, resource));
        }
    }
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
private LwM2mObjectInstance convertToServerInstance(int instanceId, ServerConfig serverConfig) {
    Collection<LwM2mResource> resources = new ArrayList<>();

    resources.add(LwM2mSingleResource.newIntegerResource(0, serverConfig.shortId));
    resources.add(LwM2mSingleResource.newIntegerResource(1, serverConfig.lifetime));
    if (serverConfig.defaultMinPeriod != null)
        resources.add(LwM2mSingleResource.newIntegerResource(2, serverConfig.defaultMinPeriod));
    if (serverConfig.defaultMaxPeriod != null)
        resources.add(LwM2mSingleResource.newIntegerResource(3, serverConfig.defaultMaxPeriod));
    if (serverConfig.disableTimeout != null)
        resources.add(LwM2mSingleResource.newIntegerResource(5, serverConfig.disableTimeout));
    resources.add(LwM2mSingleResource.newBooleanResource(6, serverConfig.notifIfDisabled));
    if (serverConfig.binding != null)
        resources.add(LwM2mSingleResource.newStringResource(7, serverConfig.binding.name()));

    return new LwM2mObjectInstance(instanceId, resources);
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
@Override
protected CreateResponse doCreate(CreateRequest request) {
    Integer instanceId = request.getInstanceId();
    if (instanceId == null) {
        // the client is in charge to generate the id of the new instance
        if (instances.isEmpty()) {
            instanceId = 0;
        } else {
            instanceId = Collections.max(instances.keySet()) + 1;
        }
    }

    LwM2mInstanceEnabler newInstance = instanceFactory.create(getObjectModel());

    for (LwM2mResource resource : request.getResources()) {
        newInstance.write(resource.getId(), resource);
    }
    instances.put(instanceId, newInstance);
    listenInstance(newInstance, instanceId);

    return CreateResponse.success(new LwM2mPath(request.getPath().getObjectId(), instanceId).toString());
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
@Override
public WriteResponse write(int resourceid, LwM2mResource value) {

    switch (resourceid) {

    case 14: // utc offset
        utcOffset = (String) value.getValue();
        fireResourcesChange(resourceid);
        return WriteResponse.success();

    case 15: // timezone
        timezone = (String) value.getValue();
        fireResourcesChange(resourceid);
        return WriteResponse.success();

    default:
        return super.write(resourceid, value);
    }
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
@Test
public void can_create_instance_of_object_without_instance_id() throws InterruptedException {
    // create ACL instance
    CreateResponse response = helper.server.send(helper.getCurrentRegistration(), new CreateRequest(2,
            new LwM2mResource[] { LwM2mSingleResource.newIntegerResource(0, 123) }));

    // verify result
    assertEquals(ResponseCode.CREATED, response.getCode());
    assertEquals("2/0", response.getLocation());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));

    // create a second ACL instance
    response = helper.server.send(helper.getCurrentRegistration(), new CreateRequest(2,
            new LwM2mResource[] { LwM2mSingleResource.newIntegerResource(0, 123) }));

    // verify result
    assertEquals(ResponseCode.CREATED, response.getCode());
    assertEquals("2/1", response.getLocation());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));

}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
@Ignore
@Test
public void cannot_create_instance_without_all_required_resources() throws InterruptedException {
    // create ACL instance
    CreateResponse response = helper.server.send(helper.getCurrentRegistration(),
            new CreateRequest(2, new LwM2mResource[0]));

    // verify result
    assertEquals(ResponseCode.BAD_REQUEST, response.getCode());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));

    // try to read to check if the instance is not created
    // client registration
    ReadResponse readResponse = helper.server.send(helper.getCurrentRegistration(), new ReadRequest(2, 0));
    assertEquals(ResponseCode.NOT_FOUND, readResponse.getCode());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
private void write_string_resource(ContentFormat format) throws InterruptedException {
    // write resource
    String expectedvalue = "stringvalue";
    WriteResponse response = helper.server.send(helper.getCurrentRegistration(),
            new WriteRequest(format, TEST_OBJECT_ID, 0, STRING_RESOURCE_ID, expectedvalue));

    // verify result
    assertEquals(ResponseCode.CHANGED, response.getCode());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));

    // read resource to check the value changed
    ReadResponse readResponse = helper.server.send(helper.getCurrentRegistration(),
            new ReadRequest(TEST_OBJECT_ID, 0, STRING_RESOURCE_ID));
    LwM2mResource resource = (LwM2mResource) readResponse.getContent();
    assertEquals(expectedvalue, resource.getValue());
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
private void write_boolean_resource(ContentFormat format) throws InterruptedException {
    // write resource
    boolean expectedvalue = true;
    WriteResponse response = helper.server.send(helper.getCurrentRegistration(),
            new WriteRequest(format, TEST_OBJECT_ID, 0, BOOLEAN_RESOURCE_ID, expectedvalue));

    // verify result
    assertEquals(ResponseCode.CHANGED, response.getCode());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));

    // read resource to check the value changed
    ReadResponse readResponse = helper.server.send(helper.getCurrentRegistration(),
            new ReadRequest(TEST_OBJECT_ID, 0, BOOLEAN_RESOURCE_ID));
    LwM2mResource resource = (LwM2mResource) readResponse.getContent();
    assertEquals(expectedvalue, resource.getValue());
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
private void write_integer_resource(ContentFormat format) throws InterruptedException {
    // write resource
    long expectedvalue = 999l;
    WriteResponse response = helper.server.send(helper.getCurrentRegistration(),
            new WriteRequest(format, TEST_OBJECT_ID, 0, INTEGER_RESOURCE_ID, expectedvalue));

    // verify result
    assertEquals(ResponseCode.CHANGED, response.getCode());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));

    // read resource to check the value changed
    ReadResponse readResponse = helper.server.send(helper.getCurrentRegistration(),
            new ReadRequest(TEST_OBJECT_ID, 0, INTEGER_RESOURCE_ID));
    LwM2mResource resource = (LwM2mResource) readResponse.getContent();
    assertEquals(expectedvalue, resource.getValue());
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
private void write_float_resource(ContentFormat format) throws InterruptedException {
    // write resource
    double expectedvalue = 999.99;
    WriteResponse response = helper.server.send(helper.getCurrentRegistration(),
            new WriteRequest(format, TEST_OBJECT_ID, 0, FLOAT_RESOURCE_ID, expectedvalue));

    // verify result
    assertEquals(ResponseCode.CHANGED, response.getCode());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));

    // read resource to check the value changed
    ReadResponse readResponse = helper.server.send(helper.getCurrentRegistration(),
            new ReadRequest(TEST_OBJECT_ID, 0, FLOAT_RESOURCE_ID));
    LwM2mResource resource = (LwM2mResource) readResponse.getContent();
    assertEquals(expectedvalue, resource.getValue());
}
 

import org.eclipse.leshan.core.node.LwM2mResource; //导入依赖的package包/类
private void write_time_resource(ContentFormat format) throws InterruptedException {
    // write resource
    Date expectedvalue = new Date(946681000l); // second accuracy
    WriteResponse response = helper.server.send(helper.getCurrentRegistration(),
            new WriteRequest(format, TEST_OBJECT_ID, 0, TIME_RESOURCE_ID, expectedvalue));

    // verify result
    assertEquals(ResponseCode.CHANGED, response.getCode());
    assertNotNull(response.getCoapResponse());
    assertThat(response.getCoapResponse(), is(instanceOf(Response.class)));

    // read resource to check the value changed
    ReadResponse readResponse = helper.server.send(helper.getCurrentRegistration(),
            new ReadRequest(TEST_OBJECT_ID, 0, TIME_RESOURCE_ID));
    LwM2mResource resource = (LwM2mResource) readResponse.getContent();
    assertEquals(expectedvalue, resource.getValue());
}