与局部阴影交互

byte[] sampleGetThingShadowRequest(String thingName, String shadowName) {
    try {
        // set up IPC client to connect to the IPC server
        EventStreamRPCConnection eventStreamRpcConnection = IPCUtils.getEventStreamRpcConnection();
        GreengrassCoreIPCClient greengrassCoreIPCClient = new GreengrassCoreIPCClient(eventStreamRpcConnection);
        
        // create the GetThingShadow request
        GetThingShadowRequest getThingShadowRequest = new GetThingShadowRequest();
        getThingShadowRequest.setThingName(thingName);
        getThingShadowRequest.setShadowName(shadowName);
        
        // retrieve the GetThingShadow response after sending the request to the IPC server
        GetThingShadowResponse getThingShadowResponse =
                greengrassCoreIPCClient.getThingShadow(getThingShadowRequest, Optional.empty())
                .getResponse()
                .get();
        
        byte[] payload = getThingShadowResponse.getPayload();
        return payload;
        
    catch (ExecutionException e) {
        if (e.getCause() instanceof InvalidArgumentsError) {
        // add error handling
        }
        ...
    // catch ResourceNotFoundError | UnauthorizedError | ServiceError
    }
}

import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import GetThingShadowRequest

TIMEOUT = 10

def sample_get_thing_shadow_request(thingName, shadowName):
    try:
        # set up IPC client to connect to the IPC server
        ipc_client = awsiot.greengrasscoreipc.connect()
                
        # create the GetThingShadow request
        get_thing_shadow_request = GetThingShadowRequest()
        get_thing_shadow_request.thing_name = thingName
        get_thing_shadow_request.shadow_name = shadowName
        
        # retrieve the GetThingShadow response after sending the request to the IPC server
        op = ipc_client.new_get_thing_shadow()
        op.activate(get_thing_shadow_request)
        fut = op.get_response()
        
        result = fut.result(TIMEOUT)
        return result.payload
        
    except InvalidArgumentsError as e:
        # add error handling
        ...
    # except ResourceNotFoundError | UnauthorizedError | ServiceError

byte[] sampleUpdateThingShadowRequest(String thingName, String shadowName, byte[] updateDocument) {
    try {
        // set up IPC client to connect to the IPC server
        EventStreamRPCConnection eventStreamRpcConnection = IPCUtils.getEventStreamRpcConnection();
        GreengrassCoreIPCClient greengrassCoreIPCClient = new GreengrassCoreIPCClient(eventStreamRpcConnection);
        
        // create the UpdateThingShadow request
        UpdateThingShadowRequest updateThingShadowRequest = new UpdateThingShadowRequest();
        updateThingShadowRequest.setThingName(thingName);
        updateThingShadowRequest.setShadowName(shadowName);
        updateThingShadowRequest.setPayload(updateDocument);
        
        // retrieve the UpdateThingShadow response after sending the request to the IPC server
        UpdateThingShadowRespone updateThingShadowResponse =
                greengrassCoreIPCClient.updateThingShadow(updateThingShadowRequest, Optional.empty())
                .getResponse()
                .get();
        
        byte[] payload = updateThingShadowResponse.getPayload();
        return payload;
        
    catch (ExecutionException e) {
        if (e.getCause() instanceof InvalidArgumentsError) {
        // add error handling
        }
        ...
    // catch ConflictError | UnauthorizedError | ServiceError 
    }
}

import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import UpdateThingShadowRequest

TIMEOUT = 10

def sample_update_thing_shadow_request(thingName, shadowName, payload):
    try:
        # set up IPC client to connect to the IPC server
        ipc_client = awsiot.greengrasscoreipc.connect()
                
        # create the UpdateThingShadow request
        update_thing_shadow_request = UpdateThingShadowRequest()
        update_thing_shadow_request.thing_name = thingName
        update_thing_shadow_request.shadow_name = shadowName
        update_thing_shadow_request.payload = payload
                        
        # retrieve the UpdateThingShadow response after sending the request to the IPC server
        op = ipc_client.new_update_thing_shadow()
        op.activate(update_thing_shadow_request)
        fut = op.get_response()
        
        result = fut.result(TIMEOUT)
        return result.payload
        
    except InvalidArgumentsError as e:
        # add error handling
    ...
    # except ConflictError | UnauthorizedError | ServiceError

byte[] sampleDeleteThingShadowRequest(String thingName, String shadowName) {
    try {
        // set up IPC client to connect to the IPC server
        EventStreamRPCConnection eventStreamRpcConnection = IPCUtils.getEventStreamRpcConnection();
        GreengrassCoreIPCClient greengrassCoreIPCClient = new GreengrassCoreIPCClient(eventStreamRpcConnection);
        
        // create the DeleteThingShadow request
        DeleteThingShadowRequest deleteThingShadowRequest = new DeleteThingShadowRequest();
        deleteThingShadowRequest.setThingName(thingName);
        deleteThingShadowRequest.setShadowName(shadowName);
        
        // retrieve the DeleteThingShadow response after sending the request to the IPC server
        DeleteThingShadowResponse deleteThingShadowResponse =
                greengrassCoreIPCClient.deleteThingShadow(deleteThingShadowRequest, Optional.empty())
                .getResponse()
                .get();
        
        byte[] payload = deleteThingShadowResponse.getPayload();
        return payload;
        
    catch (ExecutionException e) {
        if (e.getCause() instanceof InvalidArgumentsError) {
        // add error handling
        }
        ...
    // catch ResourceNotFoundError | UnauthorizedError | ServiceError
    }
}

import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import DeleteThingShadowRequest

TIMEOUT = 10

def sample_delete_thing_shadow_request(thingName, shadowName):
    try:
        # set up IPC client to connect to the IPC server
        ipc_client = awsiot.greengrasscoreipc.connect()
                
        # create the DeleteThingShadow request
        delete_thing_shadow_request = DeleteThingShadowRequest()
        delete_thing_shadow_request.thing_name = thingName
        delete_thing_shadow_request.shadow_name = shadowName
                        
        # retrieve the DeleteThingShadow response after sending the request to the IPC server
        op = ipc_client.new_delete_thing_shadow()
        op.activate(delete_thing_shadow_request)
        fut = op.get_response()
        
        result = fut.result(TIMEOUT)
        return result.payload
        
    except InvalidArgumentsError as e:
        # add error handling
    ...
    # except ResourceNotFoundError | UnauthorizedError | ServiceError

List<String> sampleListNamedShadowsForThingRequest(String thingName, String nextToken, int pageSize) {
    try {
        // set up IPC client to connect to the IPC server
        EventStreamRPCConnection eventStreamRpcConnection = IPCUtils.getEventStreamRpcConnection();
        GreengrassCoreIPCClient greengrassCoreIPCClient = new GreengrassCoreIPCClient(eventStreamRpcConnection);
        
        // create the ListNamedShadowsForThing request
        ListNamedShadowsForThingRequest request = new ListNamedShadowsForThingRequest();
        request.setThingName(thingName);
        request.setNextToken(nextToken);
        request.setPageSize(pageSize);
        
        // retrieve the ListNamedShadowsForThing response after sending the request to the IPC server
        ListThingShadowsForThingResponse response =
                greengrassCoreIPCClient.listNamedShadowsForThing(request, Optional.empty())
                .getResponse()
                .get();
        
        List<String> listOfNamedShadows = response.getResults().get()
        // pagination token used to get next set of data
        // null indicates that all named shadows were received
        String tokenForNextQuery = response.getNextToken().get()
        return listOfNamedShadows;
        
    catch (ExecutionException e) {
        if (e.getCause() instanceof InvalidArgumentsError) {
        // add error handling
        }
        ...
    // catch ResourceNotFoundError | UnauthorizedError | ServiceError
    }
}

import awsiot.greengrasscoreipc
import awsiot.greengrasscoreipc.client as client
from awsiot.greengrasscoreipc.model import ListNamedShadowsForThingRequest

TIMEOUT = 10

def sample_list_named_shadows_for_thing_request(thingName, nextToken, pageSize):
    try:
        # set up IPC client to connect to the IPC server
        ipc_client = awsiot.greengrasscoreipc.connect()
                
        # create the ListNamedShadowsForThingRequest request
        list_named_shadows_for_thing_request = ListNamedShadowsForThingRequest()
        list_named_shadows_for_thing_request.thing_name = thingName
        list_named_shadows_for_thing_request.next_token = nextToken
        list_named_shadows_for_thing_request.page_size = pageSize
        
        # retrieve the ListNamedShadowsForThingRequest response after sending the request to the IPC server
        op = ipc_client.new_list_named_shadows_for_thing()
        op.activate(list_named_shadows_for_thing_request)
        fut = op.get_response()
        
        list_result = fut.result(TIMEOUT)
        
        # additional returned fields
        timestamp = list_result.timestamp
        next_token = result.next_token
        named_shadow_list = list_result.results
        
        return named_shadow_list, next_token, timestamp
                
    except InvalidArgumentsError as e:
        # add error handling
    ...
    # except ResourceNotFoundError | UnauthorizedError | ServiceError