@autorunify/capacitor-nrfmesh 0.0.1

package/Android-nRF-Mesh-Library/mesh/src/main/java/no/nordicsemi/android/mesh/transport/MeshModelListDeserializer.java

@@ -0,0 +1,265 @@
+package no.nordicsemi.android.mesh.transport;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.UUID;
+
+import androidx.annotation.NonNull;
+import no.nordicsemi.android.mesh.models.SigModelParser;
+import no.nordicsemi.android.mesh.models.VendorModel;
+import no.nordicsemi.android.mesh.utils.MeshAddress;
+import no.nordicsemi.android.mesh.utils.MeshParserUtils;
+
+import static no.nordicsemi.android.mesh.utils.MeshParserUtils.RESOLUTION_100_MS;
+import static no.nordicsemi.android.mesh.utils.MeshParserUtils.RESOLUTION_10_M;
+import static no.nordicsemi.android.mesh.utils.MeshParserUtils.RESOLUTION_10_S;
+import static no.nordicsemi.android.mesh.utils.MeshParserUtils.RESOLUTION_1_S;
+
+/**
+ * Class for de-serializing a list of elements stored in the Mesh Configuration Database
+ */
+public final class MeshModelListDeserializer implements JsonSerializer<List<MeshModel>>, JsonDeserializer<List<MeshModel>> {
+
+    @Override
+    public List<MeshModel> deserialize(final JsonElement json, final Type typeOfT, final JsonDeserializationContext context) throws JsonParseException {
+        final List<MeshModel> meshModels = new ArrayList<>();
+        final JsonArray jsonArray = json.getAsJsonArray();
+        for (int i = 0; i < jsonArray.size(); i++) {
+            final JsonObject jsonObject = jsonArray.get(i).getAsJsonObject();
+            final int modelId = MeshParserUtils.hexToInt(jsonObject.get("modelId").getAsString());
+
+            final MeshModel meshModel = getMeshModel(modelId);
+            meshModel.mPublicationSettings = deserializePublicationSettings(jsonObject);
+            deserializeSubscription(meshModel, jsonObject);
+            final List<Integer> boundKeyIndexes = getBoundAppKeyIndexes(jsonObject);
+            meshModel.mBoundAppKeyIndexes.addAll(boundKeyIndexes);
+            meshModels.add(meshModel);
+        }
+        return meshModels;
+    }
+
+    @Override
+    public JsonElement serialize(final List<MeshModel> models, final Type typeOfSrc, final JsonSerializationContext context) {
+        final JsonArray jsonArray = new JsonArray();
+        for (MeshModel model : models) {
+            final JsonObject meshModelJson = new JsonObject();
+            if (model instanceof VendorModel) {
+                meshModelJson.addProperty("modelId", String.format(Locale.US, "%08X", model.getModelId()));
+            } else {
+                meshModelJson.addProperty("modelId", String.format(Locale.US, "%04X", model.getModelId()));
+            }
+
+            meshModelJson.add("bind", serializeBoundAppKeys(model.getBoundAppKeyIndexes()));
+            meshModelJson.add("subscribe", serializeSubscriptionAddresses(model));
+
+            if (model.getPublicationSettings() != null) {
+                meshModelJson.add("publish", serializePublicationSettings(model.getPublicationSettings()));
+            }
+
+            jsonArray.add(meshModelJson);
+        }
+        return jsonArray;
+    }
+
+    /**
+     * Get publication settings from json
+     *
+     * @param jsonObject json object
+     * @return {@link PublicationSettings}
+     */
+    private PublicationSettings deserializePublicationSettings(final JsonObject jsonObject) {
+        if (!jsonObject.has("publish"))
+            return null;
+
+        final JsonObject publish = jsonObject.get("publish").getAsJsonObject();
+
+        final String hexAddress = publish.get("address").getAsString();
+        final int publishAddress;
+        UUID uuid = null;
+        if (MeshParserUtils.isUuidPattern(hexAddress)) {
+            uuid = UUID.fromString(MeshParserUtils.formatUuid(hexAddress));
+            publishAddress = MeshAddress.generateVirtualAddress(uuid);
+        } else {
+            publishAddress = Integer.parseInt(hexAddress, 16);
+        }
+
+        final int ttl = publish.get("ttl").getAsByte();
+
+        //Previous version stored the publication period as resolution and steps.
+        //Now it's stored as an interval in ms
+        final int publicationResolution;
+        final int publicationSteps;
+        if (!publish.get("period").isJsonObject()) {
+            final int period = publish.get("period").getAsInt();
+            if (period % 600000 == 0) {
+                publicationResolution = RESOLUTION_10_M;
+                publicationSteps = period / 600000;
+            } else if (period % 10000 == 0) {
+                publicationResolution = RESOLUTION_10_S;
+                publicationSteps = period / 10000;
+            } else if (period % 1000 == 0) {
+                publicationResolution = RESOLUTION_1_S;
+                publicationSteps = period / 1000;
+            } else if (period % 100 == 0) {
+                publicationResolution = RESOLUTION_100_MS;
+                publicationSteps = period / 100;
+            } else {
+                // This is to maintain backward compatibility between older json files
+                publicationResolution = period & 0x03;
+                publicationSteps = period >> 6;
+            }
+        } else {
+            final JsonObject periodJson = publish.get("period").getAsJsonObject();
+            publicationSteps = periodJson.get("numberOfSteps").getAsInt();
+            publicationResolution = PublicationSettings.deserializePublicationResolution(periodJson.get("resolution").getAsInt());
+        }
+
+
+        final int publishRetransmitCount = publish.get("retransmit").getAsJsonObject().get("count").getAsInt();
+        // Here we should import the interval in to retransmit interval steps to maintain compatibility with iOS
+        // as well as the internal publication api
+        int publishRetransmitIntervalSteps = publish.get("retransmit").getAsJsonObject().get("interval").getAsInt();
+        if (publishRetransmitIntervalSteps >= 50) {
+            publishRetransmitIntervalSteps = PublicationSettings.parseRetransmitIntervalSteps(publishRetransmitIntervalSteps);
+        }
+        final boolean credentials = publish.get("credentials").getAsInt() == 1;
+
+        //Set the values
+        final PublicationSettings publicationSettings = new PublicationSettings();
+        publicationSettings.setPublishAddress(publishAddress);
+        publicationSettings.setLabelUUID(uuid);
+        publicationSettings.setPublishTtl(ttl);
+        publicationSettings.setPublicationSteps(publicationSteps);
+        publicationSettings.setPublicationResolution(publicationResolution);
+        publicationSettings.setPublishRetransmitCount(publishRetransmitCount);
+        publicationSettings.setPublishRetransmitIntervalSteps(publishRetransmitIntervalSteps);
+        publicationSettings.setCredentialFlag(credentials);
+
+        return publicationSettings;
+    }
+
+    /**
+     * Sets subscription addresses to a mesh model from json
+     *
+     * @param meshModel  Mesh Model
+     * @param jsonObject Json representation of the mesh model
+     */
+    private void deserializeSubscription(final MeshModel meshModel, final JsonObject jsonObject) {
+        final List<Integer> subscriptions = new ArrayList<>();
+        if (!(jsonObject.has("subscribe"))) {
+            return;
+        }
+
+        final JsonArray jsonArray = jsonObject.get("subscribe").getAsJsonArray();
+        for (int i = 0; i < jsonArray.size(); i++) {
+            final String hexAddress = jsonArray.get(i).getAsString();
+            final int address;
+            if (hexAddress.length() == 32) {
+                final UUID uuid = UUID.fromString(MeshParserUtils.formatUuid(hexAddress));
+                address = MeshAddress.generateVirtualAddress(uuid);
+                meshModel.labelUuids.add(uuid);
+            } else {
+                address = Integer.parseInt(hexAddress, 16);
+            }
+            subscriptions.add(address);
+        }
+        meshModel.subscriptionAddresses.addAll(subscriptions);
+    }
+
+    private List<Integer> getBoundAppKeyIndexes(final JsonObject jsonObject) {
+        final List<Integer> boundKeyIndexes = new ArrayList<>();
+        if (!(jsonObject.has("bind")))
+            return boundKeyIndexes;
+
+        final JsonArray jsonArray = jsonObject.get("bind").getAsJsonArray();
+        for (int i = 0; i < jsonArray.size(); i++) {
+            final int index = jsonArray.get(i).getAsInt();
+            boundKeyIndexes.add(index);
+        }
+        return boundKeyIndexes;
+    }
+
+    /**
+     * Returns JsonElement containing the subscription addresses addresses from json
+     *
+     * @param model Mesh model
+     */
+    private JsonArray serializeSubscriptionAddresses(@NonNull final MeshModel model) {
+        final JsonArray subscriptionsJson = new JsonArray();
+        for (Integer address : model.getSubscribedAddresses()) {
+            if (MeshAddress.isValidVirtualAddress(address)) {
+                subscriptionsJson.add(MeshParserUtils.uuidToHex(model.getLabelUUID(address).toString().toUpperCase(Locale.US)));
+            } else {
+                subscriptionsJson.add(MeshAddress.formatAddress(address, false));
+            }
+        }
+        return subscriptionsJson;
+    }
+
+    /**
+     * Returns JsonElement containing the subscription addresses addresses from json
+     *
+     * @param settings publication settings for this node
+     */
+    private JsonObject serializePublicationSettings(final PublicationSettings settings) {
+        final JsonObject publicationJson = new JsonObject();
+        if (MeshAddress.isValidVirtualAddress(settings.getPublishAddress()) && settings.getLabelUUID() != null) {
+            publicationJson.addProperty("address", MeshParserUtils.uuidToHex(settings.getLabelUUID()));
+        } else {
+            publicationJson.addProperty("address", MeshAddress.formatAddress(settings.getPublishAddress(), false));
+        }
+        publicationJson.addProperty("index", settings.getAppKeyIndex());
+        publicationJson.addProperty("ttl", settings.getPublishTtl());
+
+        final JsonObject periodJson = new JsonObject();
+        periodJson.addProperty("numberOfSteps", settings.getPublicationSteps());
+        periodJson.addProperty("resolution", settings.serializePublicationResolution());
+        publicationJson.add("period", periodJson);
+
+        final JsonObject retransmitJson = new JsonObject();
+        retransmitJson.addProperty("count", settings.getPublishRetransmitCount());
+        // Here we should export the retransmit interval steps as an internal to be compatible with iOS
+        retransmitJson.addProperty("interval", settings.getRetransmissionInterval());
+        publicationJson.add("retransmit", retransmitJson);
+        publicationJson.addProperty("credentials", settings.getCredentialFlag() ? 1 : 0);
+        return publicationJson;
+    }
+
+    /**
+     * Returns JsonElement containing the subscription addresses addresses from json
+     *
+     * @param boundAppKeys List of bound app key indexes
+     */
+    private JsonArray serializeBoundAppKeys(final List<Integer> boundAppKeys) {
+        final JsonArray boundAppKeyIndexes = new JsonArray();
+        for (Integer index : boundAppKeys) {
+            boundAppKeyIndexes.add(index);
+        }
+        return boundAppKeyIndexes;
+    }
+
+    /**
+     * Returns a {@link MeshModel}
+     *
+     * @param modelId model Id
+     * @return {@link MeshModel}
+     */
+    private MeshModel getMeshModel(final int modelId) {
+        if (MeshParserUtils.isVendorModel(modelId)) {
+            return new VendorModel(modelId);
+        } else {
+            return SigModelParser.getSigModel(modelId);
+        }
+    }
+}

package/Android-nRF-Mesh-Library/mesh/src/main/java/no/nordicsemi/android/mesh/transport/MeshStatusMessage.java

@@ -0,0 +1,38 @@
+package no.nordicsemi.android.mesh.transport;
+
+/**
+ * Abstract wrapper class for mesh message.
+ */
+public abstract class MeshStatusMessage {
+
+    final ProvisionedMeshNode mNode;
+    final int mOpCode;
+    final byte[] mParameters;
+
+    MeshStatusMessage(final ProvisionedMeshNode node, final int opCode, final byte[] parameters) {
+        this.mNode = node;
+        this.mOpCode = opCode;
+        this.mParameters = parameters;
+    }
+
+    /**
+     * Returns the mesh node this message must be sent to.
+     *
+     * @return provisioned mesh node
+     */
+    public abstract ProvisionedMeshNode getMeshNode();
+
+    /**
+     * Returns the opcode for this message.
+     *
+     * @return opcode
+     */
+    public abstract int getOpCode();
+
+    /**
+     * Returns the parameters of this message.
+     *
+     * @return parameters
+     */
+    public abstract byte[] getParameters();
+}

package/Android-nRF-Mesh-Library/mesh/src/main/java/no/nordicsemi/android/mesh/transport/MeshTransport.java

@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) 2018, Nordic Semiconductor
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package no.nordicsemi.android.mesh.transport;
+
+import android.content.Context;
+import android.os.Handler;
+import no.nordicsemi.android.mesh.logger.MeshLogger;
+
+import java.util.UUID;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import no.nordicsemi.android.mesh.ApplicationKey;
+import no.nordicsemi.android.mesh.MeshManagerApi;
+import no.nordicsemi.android.mesh.utils.MeshAddress;
+import no.nordicsemi.android.mesh.utils.MeshParserUtils;
+
+/**
+ * MeshTransport class is responsible for building the configuration and application layer mesh messages.
+ */
+final class MeshTransport extends NetworkLayer {
+
+    private static final String TAG = MeshTransport.class.getSimpleName();
+    private static final int PROXY_CONFIGURATION_TTL = 0;
+
+    /**
+     * Constructs the MeshTransport
+     *
+     * @param context context
+     */
+    MeshTransport(@NonNull final Context context) {
+        this.mContext = context;
+        initHandler();
+    }
+
+    /**
+     * Constructs MeshTransport
+     *
+     * @param context Context
+     * @param node    Mesh node
+     */
+    @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED)
+    MeshTransport(@NonNull final Context context, @NonNull final ProvisionedMeshNode node) {
+        super();
+        this.mContext = context;
+        this.mMeshNode = node;
+        initHandler();
+    }
+
+    @Override
+    protected void initHandler() {
+        this.mHandler = new Handler(mContext.getMainLooper());
+    }
+
+    @Override
+    protected void setLowerTransportLayerCallbacks(@NonNull final LowerTransportLayerCallbacks callbacks) {
+        mLowerTransportLayerCallbacks = callbacks;
+    }
+
+    @Override
+    void setNetworkLayerCallbacks(@NonNull final NetworkLayerCallbacks callbacks) {
+        this.mNetworkLayerCallbacks = callbacks;
+    }
+
+    @Override
+    void setUpperTransportLayerCallbacks(@NonNull final UpperTransportLayerCallbacks callbacks) {
+        this.mUpperTransportLayerCallbacks = callbacks;
+    }
+
+    /**
+     * Creates the an acknowledgement message for the received segmented messages
+     *
+     * @param controlMessage Control message containing the required opcodes and parameters to create the message
+     * @return Control message containing the acknowledgement message pdu
+     */
+    ControlMessage createSegmentBlockAcknowledgementMessage(final ControlMessage controlMessage) {
+        createLowerTransportControlPDU(controlMessage);
+        createNetworkLayerPDU(controlMessage);
+        return controlMessage;
+    }
+
+    /**
+     * Creates an access message to be sent to the peripheral node
+     * <p>
+     * This method will create the access message and propagate the message through the transport layers to create the final mesh pdu.
+     * </p>
+     *
+     * @param src                     Source address of the provisioner/configurator.
+     * @param dst                     Destination address to be sent to
+     * @param key                     Device Key
+     * @param akf                     Application key flag defines which key to be used to decrypt the message i.e device key or application key.
+     * @param aid                     Identifier of the application key.
+     * @param aszmic                  Defines the length of the transport mic length where 1 will encrypt withn 64 bit and 0 with 32 bit encryption.
+     * @param accessOpCode            Operation code for the access message.
+     * @param accessMessageParameters Parameters for the access message.
+     * @return access message containing the mesh pdu
+     */
+    AccessMessage createMeshMessage(final int src,
+                                    final int dst,
+                                    @Nullable final Integer ttl,
+                                    final byte[] key,
+                                    final int akf,
+                                    final int aid,
+                                    final int aszmic,
+                                    final int accessOpCode,
+                                    final byte[] accessMessageParameters) {
+        final ProvisionedMeshNode node = mUpperTransportLayerCallbacks.getNode(src);
+        final int sequenceNumber = node.incrementSequenceNumber();
+        final byte[] sequenceNum = MeshParserUtils.getSequenceNumberBytes(sequenceNumber);
+
+        MeshLogger.verbose(TAG, "Src address: " + MeshAddress.formatAddress(src, false));
+        MeshLogger.verbose(TAG, "Dst address: " + MeshAddress.formatAddress(dst, false));
+        // MeshLogger.verbose(TAG, "Key: " + + key.getName());
+        MeshLogger.verbose(TAG, "akf: " + akf);
+        MeshLogger.verbose(TAG, "aid: " + aid);
+        MeshLogger.verbose(TAG, "aszmic: " + aszmic);
+        MeshLogger.verbose(TAG, "Sequence number: " + sequenceNumber);
+        MeshLogger.verbose(TAG, "Access message opcode: " + Integer.toHexString(accessOpCode));
+        MeshLogger.verbose(TAG, "Access message parameters: " + MeshParserUtils.bytesToHex(accessMessageParameters, false));
+
+        final AccessMessage message = new AccessMessage();
+        message.setSrc(src);
+        message.setDst(dst);
+        message.setTtl(ttl == null ? node.getTtl() : ttl);
+        message.setIvIndex(mUpperTransportLayerCallbacks.getIvIndex());
+        message.setSequenceNumber(sequenceNum);
+        message.setDeviceKey(key);
+        message.setAkf(akf);
+        message.setAid(aid);
+        message.setAszmic(aszmic);
+        message.setOpCode(accessOpCode);
+        message.setParameters(accessMessageParameters);
+        message.setPduType(MeshManagerApi.PDU_TYPE_NETWORK);
+
+        super.createMeshMessage(message);
+        return message;
+    }
+
+    /**
+     * Creates an access message to be sent to the peripheral node
+     * <p>
+     * This method will create the access message and propagate the message through the transport layers to create the final mesh pdu.
+     * </p>
+     *
+     * @param src                     Source address of the provisioner/configurator.
+     * @param dst                     Destination address to be sent to
+     * @param label                   Label UUID for destination address
+     * @param key                     Application Key
+     * @param akf                     Application key flag defines which key to be used to decrypt the message i.e device key or application key.
+     * @param aid                     Identifier of the application key.
+     * @param aszmic                  Defines the length of the transport mic length where 1 will encrypt withn 64 bit and 0 with 32 bit encryption.
+     * @param accessOpCode            Operation code for the access message.
+     * @param accessMessageParameters Parameters for the access message.
+     * @return access message containing the mesh pdu
+     */
+    AccessMessage createMeshMessage(final int src,
+                                    final int dst,
+                                    @Nullable final UUID label,
+                                    @Nullable final Integer ttl,
+                                    @NonNull final ApplicationKey key,
+                                    final int akf,
+                                    final int aid,
+                                    final int aszmic,
+                                    final int accessOpCode,
+                                    @Nullable final byte[] accessMessageParameters) {
+        final ProvisionedMeshNode node = mUpperTransportLayerCallbacks.getNode(src);
+        final int sequenceNumber = node.incrementSequenceNumber();
+        final byte[] sequenceNum = MeshParserUtils.getSequenceNumberBytes(sequenceNumber);
+
+        MeshLogger.verbose(TAG, "Src address: " + MeshAddress.formatAddress(src, false));
+        MeshLogger.verbose(TAG, "Dst address: " + MeshAddress.formatAddress(dst, false));
+        MeshLogger.verbose(TAG, "Key: " + key.getName());
+        MeshLogger.verbose(TAG, "akf: " + akf);
+        MeshLogger.verbose(TAG, "aid: " + aid);
+        MeshLogger.verbose(TAG, "aszmic: " + aszmic);
+        MeshLogger.verbose(TAG, "Sequence number: " + sequenceNumber);
+        MeshLogger.verbose(TAG, "Access message opcode: " + Integer.toHexString(accessOpCode));
+        MeshLogger.verbose(TAG, "Access message parameters: " + MeshParserUtils.bytesToHex(accessMessageParameters, false));
+
+        final AccessMessage message = new AccessMessage();
+        message.setSrc(src);
+        message.setDst(dst);
+        message.setTtl(ttl == null ? node.getTtl() : ttl);
+        if (label != null) {
+            message.setLabel(label);
+        }
+        message.setIvIndex(mUpperTransportLayerCallbacks.getIvIndex());
+        message.setSequenceNumber(sequenceNum);
+        message.setApplicationKey(key);
+        message.setAkf(akf);
+        message.setAid(aid);
+        message.setAszmic(aszmic);
+        message.setOpCode(accessOpCode);
+        message.setParameters(accessMessageParameters);
+        message.setPduType(MeshManagerApi.PDU_TYPE_NETWORK);
+
+        super.createMeshMessage(message);
+        return message;
+    }
+
+    /**
+     * Creates a vendor model access message to be sent to the peripheral node
+     * <p>
+     * This method will create the access message and propagate the message through the transport layers to create the final mesh pdu.
+     * </p>
+     *
+     * @param src                     Source address of the provisioner/configurator.
+     * @param dst                     Destination address to be sent to
+     * @param label                   Label UUID
+     * @param key                     Application key
+     * @param akf                     Application key flag defines which key to be used to decrypt the message i.e device key or application key.
+     * @param aid                     Identifier of the application key.
+     * @param aszmic                  Defines the length of the transport mic length where 1 will encrypt within 64 bit and 0 with 32 bit encryption.
+     * @param accessOpCode            Operation code for the access message.
+     * @param accessMessageParameters Parameters for the access message.
+     * @return access message containing the mesh pdu
+     */
+    AccessMessage createVendorMeshMessage(final int companyIdentifier,
+                                          final int src,
+                                          final int dst,
+                                          @Nullable final UUID label,
+                                          @Nullable final Integer ttl,
+                                          @NonNull final ApplicationKey key,
+                                          final int akf,
+                                          final int aid,
+                                          final int aszmic,
+                                          final int accessOpCode,
+                                          @Nullable final byte[] accessMessageParameters) {
+        final ProvisionedMeshNode node = mUpperTransportLayerCallbacks.getNode(src);
+        final int sequenceNumber = node.incrementSequenceNumber();
+        final byte[] sequenceNum = MeshParserUtils.getSequenceNumberBytes(sequenceNumber);
+
+        MeshLogger.verbose(TAG, "Src address: " + MeshAddress.formatAddress(src, false));
+        MeshLogger.verbose(TAG, "Dst address: " + MeshAddress.formatAddress(dst, false));
+        MeshLogger.verbose(TAG, "Key: " + key.getName());
+        MeshLogger.verbose(TAG, "akf: " + akf);
+        MeshLogger.verbose(TAG, "aid: " + aid);
+        MeshLogger.verbose(TAG, "aszmic: " + aszmic);
+        MeshLogger.verbose(TAG, "Sequence number: " + sequenceNumber);
+        MeshLogger.verbose(TAG, "Access message opcode: " + Integer.toHexString(accessOpCode));
+        MeshLogger.verbose(TAG, "Access message parameters: " + MeshParserUtils.bytesToHex(accessMessageParameters, false));
+
+        final AccessMessage message = new AccessMessage();
+        message.setCompanyIdentifier(companyIdentifier);
+        message.setSrc(src);
+        message.setDst(dst);
+        message.setTtl(ttl == null ? node.getTtl() : ttl);
+        if (label != null) {
+            message.setLabel(label);
+        }
+        message.setIvIndex(mUpperTransportLayerCallbacks.getIvIndex());
+        message.setSequenceNumber(sequenceNum);
+        message.setApplicationKey(key);
+        message.setAkf(akf);
+        message.setAid(aid);
+        message.setAszmic(aszmic);
+        message.setOpCode(accessOpCode);
+        message.setParameters(accessMessageParameters);
+        message.setPduType(MeshManagerApi.PDU_TYPE_NETWORK);
+
+        super.createVendorMeshMessage(message);
+        return message;
+    }
+
+    /**
+     * Creates a proxy configuration message to be sent to the peripheral node
+     *
+     * @param src        Source address of the provisioner/configurator.
+     * @param dst        destination address to be sent to
+     * @param opcode     Operation code for the access message.
+     * @param parameters Parameters for the access message.
+     * @return Control message containing the proxy configuration pdu
+     */
+    ControlMessage createProxyConfigurationMessage(final int src,
+                                                   final int dst,
+                                                   final int opcode, final byte[] parameters) {
+        final ProvisionedMeshNode node = mUpperTransportLayerCallbacks.getNode(src);
+        final int sequenceNumber = node.incrementSequenceNumber();
+        final byte[] sequenceNum = MeshParserUtils.getSequenceNumberBytes(sequenceNumber);
+
+        MeshLogger.verbose(TAG, "Src address: " + MeshAddress.formatAddress(src, false));
+        MeshLogger.verbose(TAG, "Dst address: " + MeshAddress.formatAddress(dst, false));
+        MeshLogger.verbose(TAG, "Sequence number: " + sequenceNumber);
+        MeshLogger.verbose(TAG, "Control message opcode: " + Integer.toHexString(opcode));
+        MeshLogger.verbose(TAG, "Control message parameters: " + MeshParserUtils.bytesToHex(parameters, false));
+
+        final ControlMessage message = new ControlMessage();
+        message.setSrc(src);
+        message.setDst(dst);
+        message.setTtl(node.getTtl());
+        message.setTtl(PROXY_CONFIGURATION_TTL); //TTL for proxy configuration messages are set to 0
+        message.setIvIndex(mUpperTransportLayerCallbacks.getIvIndex());
+        message.setSequenceNumber(sequenceNum);
+        message.setOpCode(opcode);
+        message.setParameters(parameters);
+        message.setPduType(MeshManagerApi.PDU_TYPE_PROXY_CONFIGURATION);
+
+        super.createMeshMessage(message);
+        return message;
+    }
+
+    Message createRetransmitMeshMessage(final Message message, final int segment) {
+        return createRetransmitNetworkLayerPDU(message, segment);
+    }
+}