| /* |
| * |
| * Copyright (c) 2019-2020 Google LLC |
| * Copyright (c) 2013-2018 Nest Labs, Inc. |
| * All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @file |
| * Implementation of the native methods expected by the Java |
| * version of Weave Device Manager. |
| * |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <pthread.h> |
| #include <string> |
| #include <jni.h> |
| |
| #include <SystemLayer/SystemLayer.h> |
| #include <InetLayer/InetLayer.h> |
| #include <Weave/Core/WeaveCore.h> |
| #include <Weave/Support/CodeUtils.h> |
| #include <Weave/Core/WeaveEncoding.h> |
| #include <Weave/Profiles/WeaveProfiles.h> |
| #include <Weave/Profiles/common/CommonProfile.h> |
| #include <Weave/Profiles/network-provisioning/NetworkProvisioning.h> |
| #include <Weave/Profiles/device-description/DeviceDescription.h> |
| #include <Weave/Profiles/data-management/DataManagement.h> |
| #include <Weave/Profiles/data-management/Current/WdmManagedNamespace.h> |
| #include <Weave/Support/logging/WeaveLogging.h> |
| #include <Weave/Support/ErrorStr.h> |
| #include <Weave/Support/NLDLLUtil.h> |
| #include <Weave/Support/platform/PersistedStorage.h> |
| #include <Weave/DeviceManager/WeaveDeviceManager.h> |
| #if WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| #include <Weave/DeviceManager/WeaveDataManagementClient.h> |
| #endif // WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| #include "AndroidBleApplicationDelegate.h" |
| #include "AndroidBlePlatformDelegate.h" |
| |
| #include <net/if.h> |
| #include <errno.h> |
| |
| #ifndef PTHREAD_NULL |
| #define PTHREAD_NULL 0 |
| #endif |
| |
| using namespace nl::Inet; |
| using namespace nl::Weave; |
| using namespace nl::Weave::DeviceManager; |
| using namespace nl::Weave::Profiles::NetworkProvisioning; |
| using namespace nl::Weave::Profiles::DeviceDescription; |
| using namespace nl::Weave::Profiles::DataManagement; |
| |
| using nl::Weave::Profiles::DeviceDescription::IdentifyDeviceCriteria; |
| using nl::Weave::System::PacketBuffer; |
| |
| #define WDM_JNI_ERROR_MIN 10000 |
| #define WDM_JNI_ERROR_MAX 10999 |
| |
| #define _WDM_JNI_ERROR(e) (WDM_JNI_ERROR_MIN + (e)) |
| |
| #define WDM_JNI_ERROR_EXCEPTION_THROWN _WDM_JNI_ERROR(0) |
| #define WDM_JNI_ERROR_TYPE_NOT_FOUND _WDM_JNI_ERROR(1) |
| #define WDM_JNI_ERROR_METHOD_NOT_FOUND _WDM_JNI_ERROR(2) |
| #define WDM_JNI_ERROR_FIELD_NOT_FOUND _WDM_JNI_ERROR(3) |
| |
| #define WDM_JNI_CALLBACK_LOCAL_REF_COUNT 256 |
| |
| static JavaVM *sJVM; |
| static System::Layer sSystemLayer; |
| static InetLayer sInet; |
| #if CONFIG_NETWORK_LAYER_BLE |
| static BleLayer sBle; |
| static AndroidBleApplicationDelegate sBleApplicationDelegate; |
| static AndroidBlePlatformDelegate sBlePlatformDelegate(&sBle); |
| #endif |
| static WeaveFabricState sFabricState; |
| static WeaveMessageLayer sMessageLayer; |
| static WeaveExchangeManager sExchangeMgr; |
| static WeaveSecurityManager sSecurityMgr; |
| static pthread_mutex_t sStackLock = PTHREAD_MUTEX_INITIALIZER; |
| static pthread_t sIOThread = PTHREAD_NULL; |
| static bool sShutdown = false; |
| static jclass sNetworkInfoCls = NULL; |
| static jclass sWeaveDeviceExceptionCls = NULL; |
| static jclass sWeaveDeviceManagerExceptionCls = NULL; |
| static jclass sWeaveDeviceDescriptorCls = NULL; |
| static jclass sWirelessRegulatoryConfigCls = NULL; |
| static jclass sWeaveDeviceManagerCls = NULL; |
| static jclass sWeaveStackCls = NULL; |
| |
| extern "C" { |
| NL_DLL_EXPORT jint JNI_OnLoad(JavaVM *jvm, void *reserved); |
| NL_DLL_EXPORT void JNI_OnUnload(JavaVM *jvm, void *reserved); |
| NL_DLL_EXPORT jlong Java_nl_Weave_DeviceManager_WeaveDeviceManager_newDeviceManager(JNIEnv *env, jobject self); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_deleteDeviceManager(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectBleNoAuth(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint connObj, jboolean autoClose); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectBlePairingCode(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint connObj, jboolean autoClose, jstring pairingCodeObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectBleAccessToken(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint connObj, jboolean autoClose, jbyteArray accessToken); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectDeviceNoAuth(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong deviceId, jstring deviceAddrObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectDevicePairingCode(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong deviceId, jstring deviceAddrObj, jstring pairingCodeObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectDeviceAccessToken(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong deviceId, jstring deviceAddrObj, jbyteArray accessToken); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRendezvousDeviceNoAuth(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject deviceCriteria); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRendezvousDevicePairingCode(JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring pairingCodeObj, jobject deviceCriteria); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRendezvousDeviceAccessToken(JNIEnv *env, jobject self, jlong deviceMgrPtr, jbyteArray accessToken, jobject deviceCriteria); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRemotePassiveRendezvousNoAuth(JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring rendezvousAddrObj, jint rendezvousTimeoutSec, jint inactivityTimeoutSec); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRemotePassiveRendezvousPairingCode(JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring pairingCodeObj, jstring rendezvousAddrObj, jint rendezvousTimeoutSec, jint inactivityTimeoutSec); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRemotePassiveRendezvousAccessToken(JNIEnv *env, jobject self, jlong deviceMgrPtr, jbyteArray accessToken, jstring rendezvousAddrObj, jint rendezvousTimeoutSec, jint inactivityTimeoutSec); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginReconnectDevice(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginIdentifyDevice(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginScanNetworks(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint networkType); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetNetworks(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint flags); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetCameraAuthData(JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring nonce); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginAddNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject networkInfoObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginUpdateNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject networkInfoObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRemoveNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong networkId); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginEnableNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong networkId); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginDisableNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong networkId); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginTestNetworkConnectivity(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong networkId); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetRendezvousMode(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginSetRendezvousMode(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint rendezvousFlags); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetLastNetworkProvisioningResult(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginPing(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginPingWithSize(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint payloadSize); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRegisterServicePairAccount(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong serviceId, jstring accountId, jbyteArray serviceConfig, jbyteArray pairingToken, jbyteArray pairingInitData); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginUnregisterService(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong serviceId); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setRendezvousAddress(JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring rendezvousAddrObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setAutoReconnect(JNIEnv *env, jobject self, jlong deviceMgrPtr, jboolean autoReconnect); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setRendezvousLinkLocal(JNIEnv *env, jobject self, jlong deviceMgrPtr, jboolean rendezvousLinkLocal); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setConnectTimeout(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint timeoutMS); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginCreateFabric(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginLeaveFabric(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetFabricConfig(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginJoinExistingFabric(JNIEnv *env, jobject self, jlong deviceMgrPtr, jbyteArray fabricConfig); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginArmFailSafe(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint armMode, jint failSafeToken); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginDisarmFailSafe(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginStartSystemTest(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong profileId, jlong testId); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginStopSystemTest(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginResetConfig(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint resetFlags); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginEnableConnectionMonitor(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint interval, jint timeout); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginDisableConnectionMonitor(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginPairToken(JNIEnv *env, jobject self, jlong deviceMgrPtr, jbyteArray pairingToken); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginUnpairToken(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetWirelessRegulatoryConfig(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginSetWirelessRegulatoryConfig(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject regConfigObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_close(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT jboolean Java_nl_Weave_DeviceManager_WeaveDeviceManager_isConnected(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT jlong Java_nl_Weave_DeviceManager_WeaveDeviceManager_deviceId(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT jstring Java_nl_Weave_DeviceManager_WeaveDeviceManager_deviceAddress(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT jboolean Java_nl_Weave_DeviceManager_WeaveDeviceManager_isValidPairingCode(JNIEnv *env, jclass cls, jstring pairingCodeObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_closeEndpoints(JNIEnv *env, jclass cls); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setLogFilter(JNIEnv *env, jclass cls, jint logLevel); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_startDeviceEnumeration(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject deviceCriteriaObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveDeviceManager_stopDeviceEnumeration(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveStack_handleWriteConfirmation(JNIEnv *env, jobject self, jint connObj, jbyteArray svcIdObj, jbyteArray charIdObj, jboolean success); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveStack_handleIndicationReceived(JNIEnv *env, jobject self, jint connObj, jbyteArray svcIdObj, jbyteArray charIdObj, jbyteArray dataObj); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveStack_handleSubscribeComplete(JNIEnv *env, jobject self, jint connObj, jbyteArray svcIdObj, jbyteArray charIdObj, jboolean success); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveStack_handleUnsubscribeComplete(JNIEnv *env, jobject self, jint connObj, jbyteArray svcIdObj, jbyteArray charIdObj, jboolean success); |
| NL_DLL_EXPORT void Java_nl_Weave_DeviceManager_WeaveStack_handleConnectionError(JNIEnv *env, jobject self, jint connObj); |
| NL_DLL_EXPORT jobject Java_nl_Weave_DeviceManager_WeaveDeviceDescriptor_decode(JNIEnv *env, jclass cls, jbyteArray encodedDesc); |
| #if WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_WdmClientImpl_init(JNIEnv *env, jobject self); |
| NL_DLL_EXPORT jlong Java_nl_Weave_DataManagement_WdmClientImpl_newWdmClient(JNIEnv *env, jobject self, jlong deviceMgrPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_WdmClientImpl_deleteWdmClient(JNIEnv *env, jobject self, jlong wdmClientPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_WdmClientImpl_setNodeId(JNIEnv *env, jobject self, jlong wdmClientPtr, jlong nodeId); |
| NL_DLL_EXPORT jlong Java_nl_Weave_DataManagement_WdmClientImpl_newDataSink(JNIEnv *env, jobject self, jlong wdmClientPtr, jobject resourceIdentifierObj, jlong profileId, jlong instanceId, jstring path); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_WdmClientImpl_beginFlushUpdate(JNIEnv *env, jobject self, jlong wdmClientPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_WdmClientImpl_beginRefreshData(JNIEnv *env, jobject self, jlong wdmClientPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_init(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_shutdown(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_clear(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_beginRefreshData(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setInt(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jlong value, jboolean isConditional, jboolean isSigned); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setDouble(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jdouble value, jboolean isConditional); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setBoolean(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jboolean value, jboolean isConditional); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setString(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jstring value, jboolean isConditional); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setNull(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jboolean isConditional); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setBytes(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jbyteArray value, jboolean isConditional); |
| NL_DLL_EXPORT void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setStringArray(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jobjectArray stringArray, jboolean isConditional); |
| NL_DLL_EXPORT jlong Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getLong(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path); |
| NL_DLL_EXPORT jdouble Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getDouble(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path); |
| NL_DLL_EXPORT jboolean Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getBoolean(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path); |
| NL_DLL_EXPORT jstring Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getString(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path); |
| NL_DLL_EXPORT jboolean Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_isNull(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path); |
| NL_DLL_EXPORT jbyteArray Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getBytes(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path); |
| NL_DLL_EXPORT jobjectArray Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getStringArray(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path); |
| NL_DLL_EXPORT jlong Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getVersion(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr); |
| #endif // WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| }; |
| |
| static void HandleIdentifyDeviceComplete(WeaveDeviceManager *deviceMgr, void *reqState, const WeaveDeviceDescriptor *deviceDesc); |
| static void HandleNetworkScanComplete(WeaveDeviceManager *deviceMgr, void *reqState, uint16_t netCount, const NetworkInfo *netInfoList); |
| static void HandleGetNetworksComplete(WeaveDeviceManager *deviceMgr, void *reqState, uint16_t netCount, const NetworkInfo *netInfoList); |
| static void HandleGetCameraAuthDataComplete(WeaveDeviceManager *deviceMgr, void *reqState, const char *macAddress, const char *signedPayload); |
| static void HandleAddNetworkComplete(WeaveDeviceManager *deviceMgr, void *reqState, uint32_t networkId); |
| static void HandleGetRendezvousModeComplete(WeaveDeviceManager *deviceMgr, void *reqState, uint16_t modeFlags); |
| static void HandleGetFabricConfigComplete(WeaveDeviceManager *deviceMgr, void *reqState, const uint8_t *fabricConfig, uint32_t fabricConfigLen); |
| static void HandleDeviceEnumerationResponse(WeaveDeviceManager *deviceMgr, void *reqState, const DeviceDescription::WeaveDeviceDescriptor *devdesc, IPAddress deviceAddr, InterfaceId deviceIntf); |
| static void HandleGenericOperationComplete(jobject obj, void *reqState); |
| static void HandleSimpleOperationComplete(WeaveDeviceManager *deviceMgr, void *reqState); |
| static void HandleWdmClientComplete(void *context, void *reqState); |
| static void HandleGenericTraitUpdatableDataSinkComplete(void *context, void *reqState); |
| static void HandleNotifyWeaveConnectionClosed(BLE_CONNECTION_OBJECT connObj); |
| static bool HandleSendCharacteristic(BLE_CONNECTION_OBJECT connObj, const uint8_t *svcId, const uint8_t *charId, const uint8_t *characteristicData, uint32_t characteristicDataLen); |
| static bool HandleSubscribeCharacteristic(BLE_CONNECTION_OBJECT connObj, const uint8_t *svcId, const uint8_t *charId); |
| static bool HandleUnsubscribeCharacteristic(BLE_CONNECTION_OBJECT connObj, const uint8_t *svcId, const uint8_t *charId); |
| static void HandlePairTokenComplete(WeaveDeviceManager *deviceMgr, void *reqState, const uint8_t *pairingTokenBundle, uint32_t pairingTokenBundleLen); |
| static void HandleUnpairTokenComplete(WeaveDeviceManager *deviceMgr, void *reqState); |
| static void HandleGetWirelessRegulatoryConfigComplete(WeaveDeviceManager *deviceMgr, void *reqState, const WirelessRegConfig * regConfig); |
| static bool HandleCloseConnection(BLE_CONNECTION_OBJECT connObj); |
| static uint16_t HandleGetMTU(BLE_CONNECTION_OBJECT connObj); |
| static void HandleGenericError(jobject obj, void *reqState, WEAVE_ERROR deviceErr, DeviceStatus *devStatus); |
| static void HandleError(WeaveDeviceManager *deviceMgr, void *reqState, WEAVE_ERROR err, DeviceStatus *devStatus); |
| #if WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| static void HandleWdmClientError(void *appState, void *reqState, WEAVE_ERROR deviceErr, DeviceStatus *devStatus); |
| static void HandleGenericTraitUpdatableDataSinkError(void *context, void *reqState, WEAVE_ERROR deviceErr, DeviceStatus *devStatus); |
| #endif // WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| static void ThrowError(JNIEnv *env, WEAVE_ERROR errToThrow); |
| static void ReportError(JNIEnv *env, WEAVE_ERROR cbErr, const char *cbName); |
| static void *IOThreadMain(void *arg); |
| static WEAVE_ERROR J2N_ByteArray(JNIEnv *env, jbyteArray inArray, uint8_t *& outArray, uint32_t& outArrayLen); |
| static WEAVE_ERROR J2N_ByteArrayInPlace(JNIEnv *env, jbyteArray inArray, uint8_t * outArray, uint32_t maxArrayLen); |
| static WEAVE_ERROR N2J_ByteArray(JNIEnv *env, const uint8_t *inArray, uint32_t inArrayLen, jbyteArray& outArray); |
| static WEAVE_ERROR N2J_NewStringUTF(JNIEnv *env, const char *inStr, jstring& outString); |
| static WEAVE_ERROR N2J_NewStringUTF(JNIEnv *env, const char *inStr, size_t inStrLen, jstring& outString); |
| static WEAVE_ERROR J2N_EnumFieldVal(JNIEnv *env, jobject obj, const char *fieldName, const char *fieldType, int& outVal); |
| static WEAVE_ERROR J2N_ShortFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jshort& outVal); |
| static WEAVE_ERROR J2N_IntFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jint& outVal); |
| static WEAVE_ERROR J2N_LongFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jlong& outVal); |
| static WEAVE_ERROR J2N_StringFieldVal(JNIEnv *env, jobject obj, const char *fieldName, char *& outVal); |
| static WEAVE_ERROR J2N_ByteArrayFieldVal(JNIEnv *env, jobject obj, const char *fieldName, uint8_t *& outArray, uint32_t& outArrayLen); |
| static WEAVE_ERROR J2N_IdentifyDeviceCriteria(JNIEnv *env, jobject inCriteria, IdentifyDeviceCriteria& outCriteria); |
| static WEAVE_ERROR J2N_NetworkInfo(JNIEnv *env, jobject inNetworkInfo, NetworkInfo& outNetworkInfo); |
| static WEAVE_ERROR N2J_NetworkInfo(JNIEnv *env, const NetworkInfo& inNetworkInfo, jobject& outNetworkInfo); |
| static WEAVE_ERROR N2J_NetworkInfoArray(JNIEnv *env, const NetworkInfo *inArray, uint32_t inArrayLen, jobjectArray& outArray); |
| static WEAVE_ERROR N2J_DeviceDescriptor(JNIEnv *env, const WeaveDeviceDescriptor& inDeviceDesc, jobject& outDeviceDesc); |
| static WEAVE_ERROR J2N_WirelessRegulatoryConfig(JNIEnv *env, jobject inRegConfig, WirelessRegConfig & outRegConfig); |
| static WEAVE_ERROR N2J_WirelessRegulatoryConfig(JNIEnv *env, const WirelessRegConfig& inRegConfig, jobject& outRegConfig); |
| static WEAVE_ERROR N2J_Error(JNIEnv *env, WEAVE_ERROR inErr, jthrowable& outEx); |
| static WEAVE_ERROR N2J_DeviceStatus(JNIEnv *env, DeviceStatus& devStatus, jthrowable& outEx); |
| static WEAVE_ERROR J2N_ResourceIdentifier(JNIEnv *env, jobject inResourceIdentifier, ResourceIdentifier& outResourceIdentifier); |
| static WEAVE_ERROR GetClassRef(JNIEnv *env, const char *clsType, jclass& outCls); |
| static WEAVE_ERROR J2N_StdString(JNIEnv *env, jstring inString, std::string& outString); |
| |
| static void EngineEventCallback(void * const aAppState, |
| SubscriptionEngine::EventID aEvent, |
| const SubscriptionEngine::InEventParam & aInParam, SubscriptionEngine::OutEventParam & aOutParam); |
| static void BindingEventCallback (void * const apAppState, const nl::Weave::Binding::EventType aEvent, |
| const nl::Weave::Binding::InEventParam & aInParam, nl::Weave::Binding::OutEventParam & aOutParam); |
| template<typename GetElementFunct> |
| WEAVE_ERROR N2J_GenericArray(JNIEnv *env, uint32_t arrayLen, jclass arrayElemCls, jobjectArray& outArray, GetElementFunct getElem); |
| |
| #if CURRENTLY_UNUSED |
| static WEAVE_ERROR J2N_EnumVal(JNIEnv *env, jobject enumObj, int& outVal); |
| static WEAVE_ERROR J2N_IntFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jint& outVal); |
| #endif |
| |
| jint JNI_OnLoad(JavaVM *jvm, void *reserved) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveMessageLayer::InitContext initContext; |
| JNIEnv *env; |
| int pthreadErr = 0; |
| pthread_mutexattr_t stackLockAttrs; |
| |
| WeaveLogProgress(DeviceManager, "JNI_OnLoad() called"); |
| |
| // Save a reference to the JVM. The IO thread will need this to call back into Java. |
| sJVM = jvm; |
| |
| // Get a JNI environment object. |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| WeaveLogProgress(DeviceManager, "Loading Java class references."); |
| |
| // Get various class references need by the API. |
| err = GetClassRef(env, "nl/Weave/DeviceManager/NetworkInfo", sNetworkInfoCls); |
| SuccessOrExit(err); |
| err = GetClassRef(env, "nl/Weave/DeviceManager/WeaveDeviceException", sWeaveDeviceExceptionCls); |
| SuccessOrExit(err); |
| err = GetClassRef(env, "nl/Weave/DeviceManager/WeaveDeviceManagerException", sWeaveDeviceManagerExceptionCls); |
| SuccessOrExit(err); |
| err = GetClassRef(env, "nl/Weave/DeviceManager/WeaveDeviceDescriptor", sWeaveDeviceDescriptorCls); |
| SuccessOrExit(err); |
| err = GetClassRef(env, "nl/Weave/DeviceManager/WirelessRegulatoryConfig", sWirelessRegulatoryConfigCls); |
| SuccessOrExit(err); |
| err = GetClassRef(env, "nl/Weave/DeviceManager/WeaveDeviceManager", sWeaveDeviceManagerCls); |
| SuccessOrExit(err); |
| err = GetClassRef(env, "nl/Weave/DeviceManager/WeaveStack", sWeaveStackCls); |
| SuccessOrExit(err); |
| WeaveLogProgress(DeviceManager, "Java class references loaded."); |
| |
| // Initialize the lock that will be used to protect the stack. Note that this needs to allow recursive acquisition. |
| pthread_mutexattr_init(&stackLockAttrs); |
| pthread_mutexattr_settype(&stackLockAttrs, PTHREAD_MUTEX_RECURSIVE); |
| pthreadErr = pthread_mutex_init(&sStackLock, &stackLockAttrs); |
| VerifyOrExit(pthreadErr == 0, err = System::MapErrorPOSIX(pthreadErr)); |
| |
| // Initialize the underlying platform secure random source. |
| err = nl::Weave::Platform::Security::InitSecureRandomDataSource(NULL, 64, NULL, 0); |
| SuccessOrExit(err); |
| |
| // Initialize the Weave System Layer object |
| err = sSystemLayer.Init(NULL); |
| SuccessOrExit(err); |
| |
| // Initialize the InetLayer object. |
| err = sInet.Init(sSystemLayer, NULL); |
| SuccessOrExit(err); |
| |
| #if CONFIG_NETWORK_LAYER_BLE |
| // Initialize the ApplicationDelegate |
| sBleApplicationDelegate.SetNotifyWeaveConnectionClosedCallback(HandleNotifyWeaveConnectionClosed); |
| // Initialize the PlatformDelegate |
| sBlePlatformDelegate.SetSendWriteRequestCallback(HandleSendCharacteristic); |
| sBlePlatformDelegate.SetSubscribeCharacteristicCallback(HandleSubscribeCharacteristic); |
| sBlePlatformDelegate.SetUnsubscribeCharacteristicCallback(HandleUnsubscribeCharacteristic); |
| sBlePlatformDelegate.SetCloseConnectionCallback(HandleCloseConnection); |
| sBlePlatformDelegate.SetGetMTUCallback(HandleGetMTU); |
| // Initialize the BleLayer object. |
| err = sBle.Init(&sBlePlatformDelegate, &sBleApplicationDelegate, &sSystemLayer); |
| SuccessOrExit(err); |
| #endif |
| // Initialize the FabricState object. |
| err = sFabricState.Init(); |
| SuccessOrExit(err); |
| |
| // Not a member of a fabric. |
| sFabricState.FabricId = 0; |
| |
| // Generate a unique node id for local Weave stack. |
| err = GenerateWeaveNodeId(sFabricState.LocalNodeId); |
| SuccessOrExit(err); |
| |
| // Initialize the WeaveMessageLayer object. |
| initContext.systemLayer = &sSystemLayer; |
| initContext.inet = &sInet; |
| initContext.fabricState = &sFabricState; |
| initContext.listenTCP = false; |
| #if WEAVE_CONFIG_DEVICE_MGR_DEMAND_ENABLE_UDP |
| initContext.listenUDP = false; |
| #else |
| initContext.listenUDP = true; |
| #endif |
| #if CONFIG_NETWORK_LAYER_BLE |
| initContext.ble = &sBle; |
| initContext.listenBLE = true; |
| #endif |
| #if WEAVE_CONFIG_ENABLE_EPHEMERAL_UDP_PORT |
| initContext.enableEphemeralUDPPort = true; |
| #endif |
| err = sMessageLayer.Init(&initContext); |
| SuccessOrExit(err); |
| |
| // Initialize the Exchange Manager object. |
| err = sExchangeMgr.Init(&sMessageLayer); |
| SuccessOrExit(err); |
| |
| // Initialize the Security Manager object. |
| err = sSecurityMgr.Init(sExchangeMgr, sSystemLayer); |
| SuccessOrExit(err); |
| |
| // Create and start the IO thread. |
| sShutdown = false; |
| pthreadErr = pthread_create(&sIOThread, NULL, IOThreadMain, NULL); |
| VerifyOrExit(pthreadErr == 0, err = System::MapErrorPOSIX(pthreadErr)); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| ThrowError(env, err); |
| JNI_OnUnload(jvm, reserved); |
| } |
| |
| return (err == WEAVE_NO_ERROR) ? JNI_VERSION_1_2 : JNI_ERR; |
| } |
| |
| void JNI_OnUnload(JavaVM *jvm, void *reserved) |
| { |
| JNIEnv *env; |
| |
| WeaveLogProgress(DeviceManager, "JNI_OnUnload() called"); |
| |
| // Get a JNI environment object. |
| jvm->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| // If the IO thread has been started, tell it to shutdown and wait for it to exit. |
| if (sIOThread != PTHREAD_NULL) |
| { |
| sShutdown = true; |
| sSystemLayer.WakeSelect(); |
| pthread_join(sIOThread, NULL); |
| } |
| |
| sSecurityMgr.Shutdown(); |
| sExchangeMgr.Shutdown(); |
| sMessageLayer.Shutdown(); |
| sFabricState.Shutdown(); |
| #if CONFIG_NETWORK_LAYER_BLE |
| sBle.Shutdown(); |
| #endif |
| sInet.Shutdown(); |
| sSystemLayer.Shutdown(); |
| |
| pthread_mutex_destroy(&sStackLock); |
| |
| sJVM = NULL; |
| } |
| |
| jlong Java_nl_Weave_DeviceManager_WeaveDeviceManager_newDeviceManager(JNIEnv *env, jobject self) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = NULL; |
| long res = 0; |
| |
| WeaveLogProgress(DeviceManager, "newDeviceManager() called"); |
| |
| deviceMgr = new WeaveDeviceManager(); |
| VerifyOrExit(deviceMgr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = deviceMgr->Init(&sExchangeMgr, &sSecurityMgr); |
| SuccessOrExit(err); |
| |
| deviceMgr->AppState = (void *)env->NewGlobalRef(self); |
| |
| res = (long)deviceMgr; |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| if (deviceMgr != NULL) |
| { |
| if (deviceMgr->AppState != NULL) |
| env->DeleteGlobalRef((jobject)deviceMgr->AppState); |
| deviceMgr->Shutdown(); |
| delete deviceMgr; |
| } |
| |
| if (err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| return res; |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_deleteDeviceManager(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "deleteDeviceManager() called"); |
| |
| if (deviceMgr != NULL) |
| { |
| if (deviceMgr->AppState != NULL) |
| env->DeleteGlobalRef((jobject)deviceMgr->AppState); |
| |
| deviceMgr->Shutdown(); |
| |
| delete deviceMgr; |
| } |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectBleNoAuth(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint connObj, jboolean autoClose) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "connectBle() called"); |
| |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ConnectBle(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), (void *)"ConnectBle", HandleSimpleOperationComplete, |
| HandleError, (bool)autoClose); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectBlePairingCode(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint connObj, jboolean autoClose, jstring pairingCodeObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| const char *pairingCodeStr = NULL; |
| |
| WeaveLogProgress(DeviceManager, "connectBle() called with pairing code"); |
| |
| pairingCodeStr = env->GetStringUTFChars(pairingCodeObj, 0); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ConnectBle(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), pairingCodeStr, (void *)"ConnectBle", HandleSimpleOperationComplete, HandleError, (bool)autoClose); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| if (pairingCodeStr != NULL) |
| env->ReleaseStringUTFChars(pairingCodeObj, pairingCodeStr); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectBleAccessToken(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint connObj, jboolean autoClose, jbyteArray accessTokenObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| uint8_t *accessToken = NULL; |
| uint32_t accessTokenLen; |
| |
| WeaveLogProgress(DeviceManager, "connectBle() called with access token"); |
| |
| err = J2N_ByteArray(env, accessTokenObj, accessToken, accessTokenLen); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ConnectBle(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), accessToken, accessTokenLen, (void *)"ConnectBle", HandleSimpleOperationComplete, HandleError, (bool)autoClose); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| if (accessToken != NULL) |
| free(accessToken); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectDeviceNoAuth(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong deviceId, jstring deviceAddrObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| IPAddress deviceAddr; |
| |
| WeaveLogProgress(DeviceManager, "beginConnectDevice() called with no auth"); |
| |
| if (deviceAddrObj != NULL) |
| { |
| const char *deviceAddrStr = env->GetStringUTFChars(deviceAddrObj, 0); |
| bool res = IPAddress::FromString(deviceAddrStr, deviceAddr); |
| env->ReleaseStringUTFChars(deviceAddrObj, deviceAddrStr); |
| |
| if (!res) |
| ExitNow(err = WEAVE_ERROR_INVALID_ADDRESS); |
| } |
| else |
| deviceAddr = IPAddress::Any; |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ConnectDevice((uint64_t)deviceId, deviceAddr, (void *)"ConnectDevice", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectDevicePairingCode(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong deviceId, jstring deviceAddrObj, jstring pairingCodeObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| IPAddress deviceAddr; |
| const char *pairingCodeStr = NULL; |
| |
| WeaveLogProgress(DeviceManager, "beginConnectDevice() called with pairing code"); |
| |
| if (deviceAddrObj != NULL) |
| { |
| const char *deviceAddrStr = env->GetStringUTFChars(deviceAddrObj, 0); |
| bool res = IPAddress::FromString(deviceAddrStr, deviceAddr); |
| env->ReleaseStringUTFChars(deviceAddrObj, deviceAddrStr); |
| |
| if (!res) |
| ExitNow(err = WEAVE_ERROR_INVALID_ADDRESS); |
| } |
| else |
| deviceAddr = IPAddress::Any; |
| |
| pairingCodeStr = env->GetStringUTFChars(pairingCodeObj, 0); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ConnectDevice((uint64_t)deviceId, deviceAddr, pairingCodeStr, (void *)"ConnectDevice", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| if (pairingCodeStr != NULL) |
| env->ReleaseStringUTFChars(pairingCodeObj, pairingCodeStr); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginConnectDeviceAccessToken(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong deviceId, jstring deviceAddrObj, jbyteArray accessTokenObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| IPAddress deviceAddr; |
| uint8_t *accessToken = NULL; |
| uint32_t accessTokenLen; |
| |
| WeaveLogProgress(DeviceManager, "beginConnectDevice() called with access token"); |
| |
| if (deviceAddrObj != NULL) |
| { |
| const char *deviceAddrStr = env->GetStringUTFChars(deviceAddrObj, 0); |
| bool res = IPAddress::FromString(deviceAddrStr, deviceAddr); |
| env->ReleaseStringUTFChars(deviceAddrObj, deviceAddrStr); |
| |
| if (!res) |
| ExitNow(err = WEAVE_ERROR_INVALID_ADDRESS); |
| } |
| else |
| deviceAddr = IPAddress::Any; |
| |
| err = J2N_ByteArray(env, accessTokenObj, accessToken, accessTokenLen); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ConnectDevice((uint64_t)deviceId, deviceAddr, accessToken, accessTokenLen, (void *)"ConnectDevice", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| if (accessToken != NULL) |
| free(accessToken); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRendezvousDeviceNoAuth(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject deviceCriteriaObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| IdentifyDeviceCriteria deviceCriteria; |
| |
| WeaveLogProgress(DeviceManager, "beginRendezvousDevice() called with no auth"); |
| |
| err = J2N_IdentifyDeviceCriteria(env, deviceCriteriaObj, deviceCriteria); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->RendezvousDevice(deviceCriteria, (void *)"RendezvousDevice", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRendezvousDevicePairingCode(JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring pairingCodeObj, jobject deviceCriteriaObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| IdentifyDeviceCriteria deviceCriteria; |
| const char *pairingCodeStr = NULL; |
| |
| WeaveLogProgress(DeviceManager, "beginRendezvousDevice() called with pairing code"); |
| |
| pairingCodeStr = env->GetStringUTFChars(pairingCodeObj, 0); |
| |
| err = J2N_IdentifyDeviceCriteria(env, deviceCriteriaObj, deviceCriteria); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->RendezvousDevice(pairingCodeStr, deviceCriteria, (void *)"RendezvousDevice", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| if (pairingCodeStr != NULL) |
| env->ReleaseStringUTFChars(pairingCodeObj, pairingCodeStr); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRendezvousDeviceAccessToken(JNIEnv *env, jobject self, jlong deviceMgrPtr, jbyteArray accessTokenObj, jobject deviceCriteriaObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| IdentifyDeviceCriteria deviceCriteria; |
| uint8_t *accessToken = NULL; |
| uint32_t accessTokenLen; |
| |
| WeaveLogProgress(DeviceManager, "beginRendezvousDevice() called with access token"); |
| |
| err = J2N_ByteArray(env, accessTokenObj, accessToken, accessTokenLen); |
| SuccessOrExit(err); |
| |
| err = J2N_IdentifyDeviceCriteria(env, deviceCriteriaObj, deviceCriteria); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->RendezvousDevice(accessToken, accessTokenLen, deviceCriteria, (void *)"RendezvousDevice", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| if (accessToken != NULL) |
| free(accessToken); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRemotePassiveRendezvousNoAuth( |
| JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring rendezvousAddrObj, |
| jint rendezvousTimeoutSec, jint inactivityTimeoutSec) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| const char *rendezvousAddrStr = NULL; |
| IPAddress rendezvousAddr; |
| |
| WeaveLogProgress(DeviceManager, "beginRemotePassiveRendezvous() called with no auth"); |
| |
| rendezvousAddrStr = env->GetStringUTFChars(rendezvousAddrObj, 0); |
| VerifyOrExit(rendezvousAddrStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (!IPAddress::FromString(rendezvousAddrStr, rendezvousAddr)) |
| ExitNow(err = WEAVE_ERROR_INVALID_ADDRESS); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->RemotePassiveRendezvous(rendezvousAddr, rendezvousTimeoutSec, |
| inactivityTimeoutSec, |
| (void *)"RemotePassiveRendezvous", |
| HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| if (rendezvousAddrStr != NULL) |
| env->ReleaseStringUTFChars(rendezvousAddrObj, rendezvousAddrStr); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRemotePassiveRendezvousPairingCode( |
| JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring pairingCodeObj, |
| jstring rendezvousAddrObj, jint rendezvousTimeoutSec, jint inactivityTimeoutSec) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| const char *pairingCodeStr = NULL; |
| const char *rendezvousAddrStr = NULL; |
| IPAddress rendezvousAddr; |
| |
| WeaveLogProgress(DeviceManager, "beginRemotePassiveRendezvous() called with pairing code"); |
| |
| pairingCodeStr = env->GetStringUTFChars(pairingCodeObj, 0); |
| VerifyOrExit(pairingCodeStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| rendezvousAddrStr = env->GetStringUTFChars(rendezvousAddrObj, 0); |
| VerifyOrExit(rendezvousAddrStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (!IPAddress::FromString(rendezvousAddrStr, rendezvousAddr)) |
| ExitNow(err = WEAVE_ERROR_INVALID_ADDRESS); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->RemotePassiveRendezvous(rendezvousAddr, pairingCodeStr, rendezvousTimeoutSec, |
| inactivityTimeoutSec, (void *)"RemotePassiveRendezvous", |
| HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| if (pairingCodeStr != NULL) |
| env->ReleaseStringUTFChars(pairingCodeObj, pairingCodeStr); |
| |
| if (rendezvousAddrStr != NULL) |
| env->ReleaseStringUTFChars(rendezvousAddrObj, rendezvousAddrStr); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRemotePassiveRendezvousAccessToken( |
| JNIEnv *env, jobject self, jlong deviceMgrPtr, jbyteArray accessTokenObj, |
| jstring rendezvousAddrObj, jint rendezvousTimeoutSec, jint inactivityTimeoutSec) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| uint8_t *accessToken = NULL; |
| uint32_t accessTokenLen; |
| const char *rendezvousAddrStr = NULL; |
| IPAddress rendezvousAddr; |
| |
| WeaveLogProgress(DeviceManager, "beginRemotePassiveRendezvous() called with access token"); |
| |
| err = J2N_ByteArray(env, accessTokenObj, accessToken, accessTokenLen); |
| SuccessOrExit(err); |
| |
| rendezvousAddrStr = env->GetStringUTFChars(rendezvousAddrObj, 0); |
| VerifyOrExit(rendezvousAddrStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (!IPAddress::FromString(rendezvousAddrStr, rendezvousAddr)) |
| ExitNow(err = WEAVE_ERROR_INVALID_ADDRESS); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->RemotePassiveRendezvous(rendezvousAddr, accessToken, accessTokenLen, |
| rendezvousTimeoutSec, inactivityTimeoutSec, |
| (void *)"RemotePassiveRendezvous", |
| HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| if (accessToken != NULL) |
| free(accessToken); |
| |
| if (rendezvousAddrStr != NULL) |
| env->ReleaseStringUTFChars(rendezvousAddrObj, rendezvousAddrStr); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginReconnectDevice(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginReconnectDevice() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ReconnectDevice((void *)"ReconnectDevice", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginIdentifyDevice(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginIdentifyDevice() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->IdentifyDevice((void *)"IdentifyDevice", HandleIdentifyDeviceComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginScanNetworks(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint networkType) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginScanNetworks() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ScanNetworks((NetworkType)networkType, (void *)"ScanNetworks", HandleNetworkScanComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginAddNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject networkInfoObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| NetworkInfo networkInfo; |
| |
| WeaveLogProgress(DeviceManager, "beginAddNetwork() called"); |
| |
| err = J2N_NetworkInfo(env, networkInfoObj, networkInfo); |
| WeaveLogProgress(DeviceManager, "beginAddNetwork() J2N_NetworkInfo returned %s", nl::ErrorStr(err)); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->AddNetwork(&networkInfo, (void *)"AddNetwork", HandleAddNetworkComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginUpdateNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject networkInfoObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| NetworkInfo networkInfo; |
| |
| WeaveLogProgress(DeviceManager, "beginUpdateNetwork() called"); |
| |
| err = J2N_NetworkInfo(env, networkInfoObj, networkInfo); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->UpdateNetwork(&networkInfo, (void *)"UpdateNetwork", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRemoveNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong networkId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginRemoveNetwork() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->RemoveNetwork((uint32_t)networkId, (void *)"RemoveNetwork", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetNetworks(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint getFlags) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginGetNetworks() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->GetNetworks(getFlags, (void *)"GetNetworks", HandleGetNetworksComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetCameraAuthData(JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring nonce) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| const char *nonceStr = NULL; |
| |
| WeaveLogProgress(DeviceManager, "beginGetCameraAuthData() called"); |
| |
| nonceStr = env->GetStringUTFChars(nonce, 0); |
| VerifyOrExit(nonceStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->GetCameraAuthData(nonceStr, (void *)"GetCameraAuthData", HandleGetCameraAuthDataComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (nonceStr != NULL) |
| env->ReleaseStringUTFChars(nonce, nonceStr); |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginEnableNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong networkId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginEnableNetwork() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->EnableNetwork((uint32_t)networkId, (void *)"EnableNetwork", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginDisableNetwork(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong networkId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginDisableNetwork() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->DisableNetwork((uint32_t)networkId, (void *)"DisableNetwork", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginTestNetworkConnectivity(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong networkId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginTestNetworkConnectivity() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->TestNetworkConnectivity((uint32_t)networkId, (void *)"TestNetworkConnectivity", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetRendezvousMode(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginGetRendezvousMode() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->GetRendezvousMode((void *)"GetRendezvousMode", HandleGetRendezvousModeComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginSetRendezvousMode(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint rendezvousFlags) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginSetRendezvousMode() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->SetRendezvousMode((uint16_t)rendezvousFlags, (void *)"SetRendezvousMode", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginRegisterServicePairAccount(JNIEnv *env, jobject self, jlong deviceMgrPtr, |
| jlong serviceId, jstring accountId, jbyteArray serviceConfig, |
| jbyteArray pairingToken, jbyteArray pairingInitData) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| const uint8_t *serviceConfigBuf; |
| const uint8_t *pairingTokenBuf; |
| const uint8_t *pairingInitDataBuf; |
| const char *accountIdStr = NULL; |
| |
| WeaveLogProgress(DeviceManager, "beginRegisterServicePairAccount() called"); |
| |
| uint32_t serviceConfigLen; |
| uint32_t pairingTokenLen; |
| uint32_t pairingInitDataLen; |
| |
| serviceConfigLen = env->GetArrayLength(serviceConfig); |
| serviceConfigBuf = (const uint8_t *)env->GetByteArrayElements(serviceConfig, NULL); |
| |
| pairingTokenLen = env->GetArrayLength(pairingToken); |
| pairingTokenBuf = (const uint8_t *)env->GetByteArrayElements(pairingToken, NULL); |
| |
| pairingInitDataLen = env->GetArrayLength(pairingInitData); |
| pairingInitDataBuf = (const uint8_t *)env->GetByteArrayElements(pairingInitData, NULL); |
| |
| accountIdStr = env->GetStringUTFChars(accountId, 0); |
| VerifyOrExit(accountIdStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->RegisterServicePairAccount((uint64_t) serviceId, accountIdStr, |
| serviceConfigBuf, serviceConfigLen, |
| pairingTokenBuf, pairingTokenLen, |
| pairingInitDataBuf, pairingInitDataLen, |
| (void *)"RegisterServicePairAccount", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (accountIdStr != NULL) |
| env->ReleaseStringUTFChars(accountId, accountIdStr); |
| if (serviceConfigBuf != NULL) |
| env->ReleaseByteArrayElements(serviceConfig, (jbyte *)serviceConfigBuf, JNI_ABORT); |
| if (pairingTokenBuf != NULL) |
| env->ReleaseByteArrayElements(pairingToken, (jbyte *)pairingTokenBuf, JNI_ABORT); |
| if (pairingInitDataBuf != NULL) |
| env->ReleaseByteArrayElements(pairingInitData, (jbyte *)pairingInitDataBuf, JNI_ABORT); |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginUnregisterService(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong serviceId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginUnregisterService() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->UnregisterService((uint64_t) serviceId, (void *)"UnregisterService", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetLastNetworkProvisioningResult(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginGetLastNetworkProvisioningResult() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->GetLastNetworkProvisioningResult((void *)"GetLastNetworkProvisioningResult", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginPing(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginPingWithSize(env, self, deviceMgrPtr, 0); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginPingWithSize(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint payloadSize) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginPingWithSize() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->Ping((void *)"Ping", (int32_t)payloadSize, HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setRendezvousAddress(JNIEnv *env, jobject self, jlong deviceMgrPtr, jstring rendezvousAddrObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| const char *rendezvousAddrStr = NULL; |
| IPAddress rendezvousAddr; |
| |
| WeaveLogProgress(DeviceManager, "setRendezvousAddress() called"); |
| |
| rendezvousAddrStr = env->GetStringUTFChars(rendezvousAddrObj, 0); |
| VerifyOrExit(rendezvousAddrStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (!IPAddress::FromString(rendezvousAddrStr, rendezvousAddr)) |
| ExitNow(err = WEAVE_ERROR_INVALID_ADDRESS); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->SetWiFiRendezvousAddress(rendezvousAddr); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| if (rendezvousAddrStr != NULL) |
| env->ReleaseStringUTFChars(rendezvousAddrObj, rendezvousAddrStr); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setAutoReconnect(JNIEnv *env, jobject self, jlong deviceMgrPtr, jboolean autoReconnect) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "setAutoReconnect() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->SetAutoReconnect(autoReconnect != JNI_FALSE); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setRendezvousLinkLocal(JNIEnv *env, jobject self, jlong deviceMgrPtr, jboolean rendezvousLinkLocal) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "setRendezvousLinkLocal() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->SetRendezvousLinkLocal(rendezvousLinkLocal != JNI_FALSE); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setConnectTimeout(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint timeoutMS) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "setConnectTimeout() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->SetConnectTimeout((uint32_t)timeoutMS); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginCreateFabric(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginCreateFabric() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->CreateFabric((void *)"CreateFabric", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginLeaveFabric(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginLeaveFabric() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->LeaveFabric((void *)"LeaveFabric", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetFabricConfig(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginGetFabricConfig() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->GetFabricConfig((void *)"GetFabricConfig", HandleGetFabricConfigComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginJoinExistingFabric(JNIEnv *env, jobject self, jlong deviceMgrPtr, jbyteArray fabricConfig) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| const uint8_t *fabricConfigBuf; |
| uint32_t fabricConfigLen; |
| |
| WeaveLogProgress(DeviceManager, "beginJoinExistingFabric() called"); |
| |
| fabricConfigLen = env->GetArrayLength(fabricConfig); |
| fabricConfigBuf = (const uint8_t *)env->GetByteArrayElements(fabricConfig, NULL); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->JoinExistingFabric(fabricConfigBuf, fabricConfigLen, (void *)"JoinExistingFabric", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (fabricConfigBuf != NULL) |
| env->ReleaseByteArrayElements(fabricConfig, (jbyte *)fabricConfigBuf, JNI_ABORT); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginArmFailSafe(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint armMode, jint failSafeToken) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginArmFailSafe() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ArmFailSafe((uint8_t) armMode, (uint32_t)failSafeToken, (void *)"ArmFailSafe", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginDisarmFailSafe(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginDisarmFailSafe() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->DisarmFailSafe((void *)"DisarmFailSafe", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginStartSystemTest(JNIEnv *env, jobject self, jlong deviceMgrPtr, jlong profileId, jlong testId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginStartSystemTest() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->StartSystemTest((void *)"StartSystemTest", static_cast<uint32_t>(profileId), static_cast<uint32_t>(testId), HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginStopSystemTest(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginStopSystemTest() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->StopSystemTest((void *)"StopSystemTest", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginResetConfig(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint resetFlags) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginResetConfig() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->ResetConfig((uint16_t)resetFlags, (void *)"ResetConfig", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginEnableConnectionMonitor(JNIEnv *env, jobject self, jlong deviceMgrPtr, jint interval, jint timeout) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginEnableConnectionMonitor() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->EnableConnectionMonitor((uint16_t)interval, (uint16_t)timeout, (void *)"EnableConnectionMonitor", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginDisableConnectionMonitor(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginDisableConnectionMonitor() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->DisableConnectionMonitor((void *)"DisableConnectionMonitor", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| jboolean Java_nl_Weave_DeviceManager_WeaveDeviceManager_isValidPairingCode(JNIEnv *env, jclass cls, jstring pairingCodeObj) |
| { |
| const char *pairingCodeStr = NULL; |
| bool res; |
| |
| WeaveLogProgress(DeviceManager, "isValidPairingCode() called"); |
| |
| pairingCodeStr = env->GetStringUTFChars(pairingCodeObj, 0); |
| |
| res = WeaveDeviceManager::IsValidPairingCode(pairingCodeStr); |
| |
| env->ReleaseStringUTFChars(pairingCodeObj, pairingCodeStr); |
| |
| return res ? JNI_TRUE : JNI_FALSE; |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginPairToken(JNIEnv *env, jobject self, jlong deviceMgrPtr, jbyteArray pairingToken) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| const uint8_t *pairingTokenBuf; |
| uint32_t pairingTokenLen; |
| |
| WeaveLogProgress(DeviceManager, "beginPairToken() called"); |
| |
| pairingTokenLen = env->GetArrayLength(pairingToken); |
| pairingTokenBuf = (const uint8_t *)env->GetByteArrayElements(pairingToken, NULL); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->PairToken(pairingTokenBuf, static_cast<uint16_t>(pairingTokenLen), (void *)"PairToken", HandlePairTokenComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (pairingTokenBuf != NULL) |
| env->ReleaseByteArrayElements(pairingToken, (jbyte *)pairingTokenBuf, JNI_ABORT); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginUnpairToken(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginUnpairToken() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->UnpairToken((void *)"UnpairToken", HandleUnpairTokenComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginGetWirelessRegulatoryConfig(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginGetWirelessRegulatoryConfig() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->GetWirelessRegulatoryConfig((void *)"GetWirelessRegulatoryConfig", HandleGetWirelessRegulatoryConfigComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_beginSetWirelessRegulatoryConfig(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject regConfigObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| WirelessRegConfig regConfig; |
| |
| WeaveLogProgress(DeviceManager, "beginSetWirelessRegulatoryConfig() called"); |
| |
| regConfig.Init(); |
| |
| err = J2N_WirelessRegulatoryConfig(env, regConfigObj, regConfig); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->SetWirelessRegulatoryConfig(®Config, (void *)"SetWirelessRegulatoryConfig", HandleSimpleOperationComplete, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_closeEndpoints(JNIEnv *env, jclass cls) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| WeaveLogProgress(DeviceManager, "closeEndpoints() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = sMessageLayer.CloseEndpoints(); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_setLogFilter(JNIEnv *env, jclass cls, jint logLevel) |
| { |
| nl::Weave::Logging::SetLogFilter(logLevel); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_startDeviceEnumeration(JNIEnv *env, jobject self, jlong deviceMgrPtr, jobject deviceCriteriaObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| IdentifyDeviceCriteria deviceCriteria; |
| |
| WeaveLogProgress(DeviceManager, "startDeviceEnumeration()"); |
| |
| err = J2N_IdentifyDeviceCriteria(env, deviceCriteriaObj, deviceCriteria); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| err = deviceMgr->StartDeviceEnumeration((void *)"StartDeviceEnumeration", deviceCriteria, HandleDeviceEnumerationResponse, HandleError); |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_stopDeviceEnumeration(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "stopDeviceEnumeration()"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| deviceMgr->StopDeviceEnumeration(); |
| |
| pthread_mutex_unlock(&sStackLock); |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveStack_handleWriteConfirmation(JNIEnv *env, jobject self, jint connObj, |
| jbyteArray svcIdObj, jbyteArray charIdObj, |
| jboolean success) |
| { |
| #if CONFIG_NETWORK_LAYER_BLE |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| WeaveLogProgress(DeviceManager, "handleWriteConfirmation() called"); |
| |
| WeaveBleUUID svcId; |
| err = J2N_ByteArrayInPlace(env, svcIdObj, svcId.bytes, sizeof(svcId.bytes)); |
| SuccessOrExit(err); |
| |
| WeaveBleUUID charId; |
| err = J2N_ByteArrayInPlace(env, charIdObj, charId.bytes, sizeof(charId.bytes)); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| if (success) |
| { |
| if (!sBle.HandleWriteConfirmation(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), &svcId, &charId)) |
| { |
| err = BLE_ERROR_WOBLE_PROTOCOL_ABORT; |
| } |
| } |
| else |
| { |
| sBle.HandleConnectionError(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), BLE_ERROR_GATT_WRITE_FAILED); |
| } |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| #endif // CONFIG_NETWORK_LAYER_BLE |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveStack_handleIndicationReceived(JNIEnv *env, jobject self, jint connObj, |
| jbyteArray svcIdObj, jbyteArray charIdObj, |
| jbyteArray dataObj) |
| { |
| #if CONFIG_NETWORK_LAYER_BLE |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| WeaveLogProgress(DeviceManager, "handleIndicationReceived() called"); |
| |
| WeaveBleUUID svcId; |
| WeaveBleUUID charId; |
| PacketBuffer *msgBuf = NULL; |
| |
| err = J2N_ByteArrayInPlace(env, svcIdObj, svcId.bytes, sizeof(svcId.bytes)); |
| SuccessOrExit(err); |
| |
| err = J2N_ByteArrayInPlace(env, charIdObj, charId.bytes, sizeof(charId.bytes)); |
| SuccessOrExit(err); |
| |
| msgBuf = PacketBuffer::New(); |
| VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| |
| err = J2N_ByteArrayInPlace(env, dataObj, msgBuf->Start(), msgBuf->AvailableDataLength()); |
| if (err != WEAVE_NO_ERROR) |
| { |
| PacketBuffer::Free(msgBuf); |
| ExitNow(); |
| } |
| msgBuf->SetDataLength(env->GetArrayLength(dataObj)); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| if (!sBle.HandleIndicationReceived(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), &svcId, &charId, msgBuf)) { |
| err = BLE_ERROR_WOBLE_PROTOCOL_ABORT; |
| PacketBuffer::Free(msgBuf); |
| msgBuf = NULL; |
| } |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| #endif // CONFIG_NETWORK_LAYER_BLE |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveStack_handleSubscribeComplete(JNIEnv *env, jobject self, jint connObj, |
| jbyteArray svcIdObj, jbyteArray charIdObj, |
| jboolean success) |
| { |
| #if CONFIG_NETWORK_LAYER_BLE |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| WeaveLogProgress(DeviceManager, "handleSubscribeComplete() called"); |
| |
| WeaveBleUUID svcId; |
| err = J2N_ByteArrayInPlace(env, svcIdObj, svcId.bytes, sizeof(svcId.bytes)); |
| SuccessOrExit(err); |
| |
| WeaveBleUUID charId; |
| err = J2N_ByteArrayInPlace(env, charIdObj, charId.bytes, sizeof(charId.bytes)); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| if (success) |
| { |
| if (!sBle.HandleSubscribeComplete(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), &svcId, &charId)) |
| { |
| err = BLE_ERROR_WOBLE_PROTOCOL_ABORT; |
| } |
| } |
| else |
| { |
| sBle.HandleConnectionError(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), BLE_ERROR_GATT_SUBSCRIBE_FAILED); |
| } |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| #endif // CONFIG_NETWORK_LAYER_BLE |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveStack_handleUnsubscribeComplete(JNIEnv *env, jobject self, jint connObj, |
| jbyteArray svcIdObj, jbyteArray charIdObj, |
| jboolean success) |
| { |
| #if CONFIG_NETWORK_LAYER_BLE |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| WeaveLogProgress(DeviceManager, "handleUnsubscribeComplete() called"); |
| |
| WeaveBleUUID svcId; |
| err = J2N_ByteArrayInPlace(env, svcIdObj, svcId.bytes, sizeof(svcId.bytes)); |
| SuccessOrExit(err); |
| |
| WeaveBleUUID charId; |
| err = J2N_ByteArrayInPlace(env, charIdObj, charId.bytes, sizeof(charId.bytes)); |
| SuccessOrExit(err); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| if (success) |
| { |
| if (!sBle.HandleUnsubscribeComplete(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), &svcId, &charId)) |
| { |
| err = BLE_ERROR_WOBLE_PROTOCOL_ABORT; |
| } |
| } |
| else |
| { |
| sBle.HandleConnectionError(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), BLE_ERROR_GATT_UNSUBSCRIBE_FAILED); |
| } |
| |
| pthread_mutex_unlock(&sStackLock); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| #endif // CONFIG_NETWORK_LAYER_BLE |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveStack_handleConnectionError(JNIEnv *env, jobject self, jint connObj) |
| { |
| #if CONFIG_NETWORK_LAYER_BLE |
| WeaveLogProgress(DeviceManager, "handleConnectionError() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| |
| sBle.HandleConnectionError(reinterpret_cast<BLE_CONNECTION_OBJECT>(connObj), BLE_ERROR_REMOTE_DEVICE_DISCONNECTED); |
| |
| pthread_mutex_unlock(&sStackLock); |
| #endif |
| } |
| |
| void Java_nl_Weave_DeviceManager_WeaveDeviceManager_close(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "close() called"); |
| |
| if (deviceMgr != NULL) |
| deviceMgr->Close(); |
| } |
| |
| jboolean Java_nl_Weave_DeviceManager_WeaveDeviceManager_isConnected(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "isConnected() called"); |
| |
| return deviceMgr->IsConnected() ? JNI_TRUE : JNI_FALSE; |
| } |
| |
| jlong Java_nl_Weave_DeviceManager_WeaveDeviceManager_deviceId(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| uint64_t deviceId; |
| |
| WeaveLogProgress(DeviceManager, "deviceId() called"); |
| |
| err = deviceMgr->GetDeviceId(deviceId); |
| if (err == WEAVE_ERROR_INCORRECT_STATE) |
| { |
| err = WEAVE_NO_ERROR; // No exception, just return 0. |
| deviceId = 0; |
| } |
| |
| if (err != WEAVE_NO_ERROR) |
| ThrowError(env, err); |
| |
| return (jlong)deviceId; |
| } |
| |
| jstring Java_nl_Weave_DeviceManager_WeaveDeviceManager_deviceAddress(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| IPAddress devAddr; |
| jstring devAddrStr = NULL; |
| char devAddrStrBuf[32]; |
| |
| WeaveLogProgress(DeviceManager, "deviceAddress() called"); |
| |
| err = deviceMgr->GetDeviceAddress(devAddr); |
| if (err == WEAVE_NO_ERROR) |
| { |
| devAddr.ToString(devAddrStrBuf, sizeof(devAddrStrBuf)); |
| devAddrStr = env->NewStringUTF(devAddrStrBuf); |
| } |
| else if (err == WEAVE_ERROR_INCORRECT_STATE) |
| err = WEAVE_NO_ERROR; // No exception, just return null. |
| |
| if (err != WEAVE_NO_ERROR) |
| ThrowError(env, err); |
| |
| return devAddrStr; |
| } |
| |
| jobject Java_nl_Weave_DeviceManager_WeaveDeviceDescriptor_decode(JNIEnv *env, jclass cls, jbyteArray encodedDesc) |
| { |
| WEAVE_ERROR err; |
| const uint8_t *encodedBuf = NULL; |
| uint32_t encodedLen; |
| WeaveDeviceDescriptor deviceDesc; |
| jobject deviceDescObj = NULL; |
| |
| WeaveLogProgress(DeviceManager, "WeaveDeviceDescriptor.decode() called"); |
| |
| encodedLen = env->GetArrayLength(encodedDesc); |
| encodedBuf = (const uint8_t *)env->GetByteArrayElements(encodedDesc, NULL); |
| |
| err = WeaveDeviceDescriptor::Decode(encodedBuf, encodedLen, deviceDesc); |
| SuccessOrExit(err); |
| |
| err = N2J_DeviceDescriptor(env, deviceDesc, deviceDescObj); |
| SuccessOrExit(err); |
| |
| exit: |
| if (encodedBuf != NULL) |
| env->ReleaseByteArrayElements(encodedDesc, (jbyte *)encodedBuf, JNI_ABORT); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| ThrowError(env, err); |
| |
| return deviceDescObj; |
| } |
| |
| void *IOThreadMain(void *arg) |
| { |
| JNIEnv *env; |
| JavaVMAttachArgs attachArgs; |
| struct timeval sleepTime; |
| fd_set readFDs, writeFDs, exceptFDs; |
| int numFDs = 0; |
| |
| // Attach the IO thread to the JVM as a daemon thread. This allows the JVM to shutdown |
| // without waiting for this thread to exit. |
| attachArgs.version = JNI_VERSION_1_2; |
| attachArgs.name = (char *)"Weave Device Manager IO Thread"; |
| attachArgs.group = NULL; |
| #ifdef __ANDROID__ |
| sJVM->AttachCurrentThreadAsDaemon(&env, (void *)&attachArgs); |
| #else |
| sJVM->AttachCurrentThreadAsDaemon((void **)&env, (void *)&attachArgs); |
| #endif |
| |
| WeaveLogProgress(DeviceManager, "IO thread starting starting"); |
| |
| // Lock the stack to prevent collisions with Java threads. |
| pthread_mutex_lock(&sStackLock); |
| |
| // Loop until we told to exit. |
| while (true) |
| { |
| numFDs = 0; |
| FD_ZERO(&readFDs); |
| FD_ZERO(&writeFDs); |
| FD_ZERO(&exceptFDs); |
| |
| sleepTime.tv_sec = 10; |
| sleepTime.tv_usec = 0; |
| |
| WeaveLogProgress(DeviceManager, "IO thread starting starting debugging 1"); |
| // Collect the currently active file descriptors. |
| sSystemLayer.PrepareSelect(numFDs, &readFDs, &writeFDs, &exceptFDs, sleepTime); |
| sInet.PrepareSelect(numFDs, &readFDs, &writeFDs, &exceptFDs, sleepTime); |
| |
| // Unlock the stack so that Java threads can make API calls. |
| pthread_mutex_unlock(&sStackLock); |
| |
| WeaveLogProgress(DeviceManager, "IO thread starting starting debugging 2"); |
| // Wait for for I/O or for the next timer to expire. |
| int selectRes = select(numFDs, &readFDs, &writeFDs, &exceptFDs, &sleepTime); |
| |
| WeaveLogProgress(DeviceManager, "IO thread starting starting debugging 3"); |
| // Break the loop if requested to shutdown. |
| if (sShutdown) |
| break; |
| |
| // Re-lock the stack. |
| pthread_mutex_lock(&sStackLock); |
| |
| WeaveLogProgress(DeviceManager, "IO thread starting starting debugging 4"); |
| // Perform I/O and/or dispatch timers. |
| sSystemLayer.HandleSelectResult(selectRes, &readFDs, &writeFDs, &exceptFDs); |
| sInet.HandleSelectResult(selectRes, &readFDs, &writeFDs, &exceptFDs); |
| } |
| |
| // Detach the thread from the JVM. |
| sJVM->DetachCurrentThread(); |
| |
| return NULL; |
| } |
| |
| void HandleIdentifyDeviceComplete(WeaveDeviceManager *deviceMgr, void *reqState, const WeaveDeviceDescriptor *deviceDesc) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jobject deviceDescObj; |
| jmethodID method; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to IdentifyDevice request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = N2J_DeviceDescriptor(env, *deviceDesc, deviceDescObj); |
| SuccessOrExit(err); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onIdentifyDeviceComplete", "(Lnl/Weave/DeviceManager/WeaveDeviceDescriptor;)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onIdentifyDeviceComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, deviceDescObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleNetworkScanComplete(WeaveDeviceManager *deviceMgr, void *reqState, uint16_t netCount, const NetworkInfo *netInfoList) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jobjectArray netInfoArrayObj; |
| jmethodID method; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to ScanNetworks request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = N2J_NetworkInfoArray(env, netInfoList, netCount, netInfoArrayObj); |
| SuccessOrExit(err); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onScanNetworksComplete", "([Lnl/Weave/DeviceManager/NetworkInfo;)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onScanNetworksComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, netInfoArrayObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleGetNetworksComplete(WeaveDeviceManager *deviceMgr, void *reqState, uint16_t netCount, const NetworkInfo *netInfoList) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jobjectArray netInfoArrayObj; |
| jmethodID method; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to GetNetworks request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = N2J_NetworkInfoArray(env, netInfoList, netCount, netInfoArrayObj); |
| SuccessOrExit(err); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onGetNetworksComplete", "([Lnl/Weave/DeviceManager/NetworkInfo;)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onGetNetworksComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, netInfoArrayObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleGetCameraAuthDataComplete(WeaveDeviceManager *deviceMgr, void *reqState, const char *macAddress, const char *signedPayload) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jmethodID method; |
| jstring macAddressStr = NULL; |
| jstring signedPayloadStr = NULL; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to GetCameraAuthData request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| { |
| localFramePushed = true; |
| } |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| macAddressStr = env->NewStringUTF(macAddress); |
| signedPayloadStr = env->NewStringUTF(signedPayload); |
| |
| method = env->GetMethodID(deviceMgrCls, "onGetCameraAuthDataComplete", "(Ljava/lang/String;Ljava/lang/String;)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onGetCameraAuthDataComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, macAddressStr, signedPayloadStr); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (NULL != macAddressStr) |
| { |
| env->DeleteLocalRef(macAddressStr); |
| } |
| |
| if (NULL != signedPayloadStr) |
| { |
| env->DeleteLocalRef(signedPayloadStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR) |
| { |
| ReportError(env, err, __FUNCTION__); |
| } |
| env->ExceptionClear(); |
| if (localFramePushed) |
| { |
| env->PopLocalFrame(NULL); |
| } |
| } |
| |
| void HandleAddNetworkComplete(WeaveDeviceManager *deviceMgr, void *reqState, uint32_t networkId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jmethodID method; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to AddNetwork request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onAddNetworkComplete", "(J)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onAddNetworkComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, (jlong)networkId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleGetRendezvousModeComplete(WeaveDeviceManager *deviceMgr, void *reqState, uint16_t modeFlags) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jmethodID method; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to GetRendezvousMode request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onGetRendezvousModeComplete", "(I)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onGetRendezvousModeComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, (jint)modeFlags); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleGetFabricConfigComplete(WeaveDeviceManager *deviceMgr, void *reqState, const uint8_t *fabricConfig, uint32_t fabricConfigLen) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jbyteArray fabricConfigObj; |
| jmethodID method; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to GetFabricConfig request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = N2J_ByteArray(env, fabricConfig, fabricConfigLen, fabricConfigObj); |
| SuccessOrExit(err); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onGetFabricConfigComplete", "([B)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onGetFabricConfigComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, fabricConfigObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleDeviceEnumerationResponse(WeaveDeviceManager *deviceMgr, void *reqState, const WeaveDeviceDescriptor *deviceDesc, |
| IPAddress deviceAddr, InterfaceId deviceIntf) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jobject deviceDescObj; |
| jstring deviceAddrStr = NULL; |
| jmethodID method; |
| char deviceAddrCStr[INET6_ADDRSTRLEN + IF_NAMESIZE + 2]; // Include space for "<addr>%<interface name>" and NULL terminator |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received device enumeration response"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| { |
| localFramePushed = true; |
| } |
| |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| deviceAddr.ToString(deviceAddrCStr, sizeof(deviceAddrCStr)); |
| |
| // Add "%" separator character, with NULL terminator, per IETF RFC 4007: https://tools.ietf.org/html/rfc4007 |
| VerifyOrExit(snprintf(&(deviceAddrCStr[strlen(deviceAddrCStr)]), 2, "%%") > 0, err = System::MapErrorPOSIX(errno)); |
| |
| // Concatenate zone index (aka interface name) to IP address, with NULL terminator, per IETF RFC 4007: https://tools.ietf.org/html/rfc4007 |
| err = nl::Inet::GetInterfaceName(deviceIntf, &(deviceAddrCStr[strlen(deviceAddrCStr)]), IF_NAMESIZE + 1); |
| SuccessOrExit(err); |
| |
| deviceAddrStr = env->NewStringUTF(deviceAddrCStr); |
| |
| err = N2J_DeviceDescriptor(env, *deviceDesc, deviceDescObj); |
| SuccessOrExit(err); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onDeviceEnumerationResponse", "(Lnl/Weave/DeviceManager/WeaveDeviceDescriptor;Ljava/lang/String;)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onDeviceEnumerationResponse method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, deviceDescObj, deviceAddrStr); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| ReportError(env, err, __FUNCTION__); |
| } |
| |
| env->ExceptionClear(); |
| |
| if (localFramePushed) |
| { |
| env->DeleteLocalRef(deviceAddrStr); |
| env->PopLocalFrame(NULL); |
| } |
| } |
| |
| void HandleGenericOperationComplete(jobject obj, void *reqState) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = obj; |
| jclass cls; |
| jmethodID method; |
| char methodName[128]; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to %s request", (const char *)reqState); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| cls = env->GetObjectClass(self); |
| VerifyOrExit(cls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| snprintf(methodName, sizeof(methodName) - 1, "on%sComplete", (const char *)reqState); |
| methodName[sizeof(methodName) - 1] = 0; |
| method = env->GetMethodID(cls, methodName, "()V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java %s method", methodName); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleSimpleOperationComplete(WeaveDeviceManager *deviceMgr, void *reqState) |
| { |
| jobject self = (jobject)deviceMgr->AppState; |
| HandleGenericOperationComplete(self, reqState); |
| } |
| #if WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| void HandleWdmClientComplete(void *context, void *reqState) |
| { |
| WdmClient * wdmClient = reinterpret_cast<WdmClient *>(context); |
| jobject self = (jobject)wdmClient->mpAppState; |
| HandleGenericOperationComplete(self, reqState); |
| } |
| |
| void HandleGenericTraitUpdatableDataSinkComplete(void *context, void *reqState) |
| { |
| GenericTraitUpdatableDataSink * sink = reinterpret_cast<GenericTraitUpdatableDataSink *>(context); |
| jobject self = (jobject)sink->mpAppState; |
| HandleGenericOperationComplete(self, reqState); |
| } |
| #endif // WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| void HandleNotifyWeaveConnectionClosed(BLE_CONNECTION_OBJECT connObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jmethodID method; |
| bool localFramePushed = false; |
| intptr_t tmpConnObj; |
| |
| WeaveLogProgress(DeviceManager, "Received NotifyWeaveConnectionClosed"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| method = env->GetStaticMethodID(sWeaveStackCls, "onNotifyWeaveConnectionClosed", "(I)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java NotifyWeaveConnectionClosed"); |
| |
| env->ExceptionClear(); |
| tmpConnObj = reinterpret_cast<intptr_t>(connObj); |
| env->CallStaticVoidMethod(sWeaveStackCls, method, static_cast<jint>(tmpConnObj)); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| bool HandleSendCharacteristic(BLE_CONNECTION_OBJECT connObj, const uint8_t *svcId, const uint8_t *charId, const uint8_t *characteristicData, uint32_t characteristicDataLen) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jbyteArray svcIdObj; |
| jbyteArray charIdObj; |
| jbyteArray characteristicDataObj; |
| jmethodID method; |
| bool localFramePushed = false; |
| intptr_t tmpConnObj; |
| bool rc = false; |
| |
| WeaveLogProgress(DeviceManager, "Received SendCharacteristic"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = N2J_ByteArray(env, svcId, 16, svcIdObj); |
| SuccessOrExit(err); |
| |
| err = N2J_ByteArray(env, charId, 16, charIdObj); |
| SuccessOrExit(err); |
| |
| err = N2J_ByteArray(env, characteristicData, characteristicDataLen, characteristicDataObj); |
| SuccessOrExit(err); |
| |
| method = env->GetStaticMethodID(sWeaveStackCls, "onSendCharacteristic", "(I[B[B[B)Z"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java SendCharacteristic"); |
| |
| env->ExceptionClear(); |
| tmpConnObj = reinterpret_cast<intptr_t>(connObj); |
| rc = (bool) env->CallStaticBooleanMethod(sWeaveStackCls, method, static_cast<jint>(tmpConnObj), svcIdObj, charIdObj, characteristicDataObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| ReportError(env, err, __FUNCTION__); |
| rc = false; |
| } |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| |
| return rc; |
| } |
| |
| bool HandleSubscribeCharacteristic(BLE_CONNECTION_OBJECT connObj, const uint8_t *svcId, const uint8_t *charId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jbyteArray svcIdObj; |
| jbyteArray charIdObj; |
| jmethodID method; |
| bool localFramePushed = false; |
| intptr_t tmpConnObj; |
| bool rc = false; |
| |
| WeaveLogProgress(DeviceManager, "Received SubscribeCharacteristic"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = N2J_ByteArray(env, svcId, 16, svcIdObj); |
| SuccessOrExit(err); |
| |
| err = N2J_ByteArray(env, charId, 16, charIdObj); |
| SuccessOrExit(err); |
| |
| method = env->GetStaticMethodID(sWeaveStackCls, "onSubscribeCharacteristic", "(I[B[B)Z"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java SubscribeCharacteristic"); |
| |
| env->ExceptionClear(); |
| tmpConnObj = reinterpret_cast<intptr_t>(connObj); |
| rc = (bool) env->CallStaticBooleanMethod(sWeaveStackCls, method, static_cast<jint>(tmpConnObj), svcIdObj, charIdObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| ReportError(env, err, __FUNCTION__); |
| rc = false; |
| } |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| |
| return rc; |
| } |
| |
| bool HandleUnsubscribeCharacteristic(BLE_CONNECTION_OBJECT connObj, const uint8_t *svcId, const uint8_t *charId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jbyteArray svcIdObj; |
| jbyteArray charIdObj; |
| jmethodID method; |
| bool localFramePushed = false; |
| intptr_t tmpConnObj; |
| bool rc = false; |
| |
| WeaveLogProgress(DeviceManager, "Received UnsubscribeCharacteristic"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = N2J_ByteArray(env, svcId, 16, svcIdObj); |
| SuccessOrExit(err); |
| |
| err = N2J_ByteArray(env, charId, 16, charIdObj); |
| SuccessOrExit(err); |
| |
| method = env->GetStaticMethodID(sWeaveStackCls, "onUnsubscribeCharacteristic", "(I[B[B)Z"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java UnsubscribeCharacteristic"); |
| |
| env->ExceptionClear(); |
| tmpConnObj = reinterpret_cast<intptr_t>(connObj); |
| rc = (bool) env->CallStaticBooleanMethod(sWeaveStackCls, method, static_cast<jint>(tmpConnObj), svcIdObj, charIdObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| ReportError(env, err, __FUNCTION__); |
| rc = false; |
| } |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| |
| return rc; |
| } |
| |
| void HandlePairTokenComplete(WeaveDeviceManager *deviceMgr, void *reqState, const uint8_t *pairingTokenBundle, uint32_t pairingTokenBundleLen) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jbyteArray pairingTokenBundleObj; |
| jmethodID method; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to PairToken request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = N2J_ByteArray(env, pairingTokenBundle, pairingTokenBundleLen, pairingTokenBundleObj); |
| SuccessOrExit(err); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onPairTokenComplete", "([B)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onPairTokenComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, pairingTokenBundleObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleUnpairTokenComplete(WeaveDeviceManager *deviceMgr, void *reqState) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jmethodID method; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to UnpairToken request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onUnpairTokenComplete", "()V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onUnpairTokenComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleGetWirelessRegulatoryConfigComplete(WeaveDeviceManager *deviceMgr, void *reqState, const WirelessRegConfig * regConfig) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = (jobject)deviceMgr->AppState; |
| jclass deviceMgrCls; |
| jobject regConfigObj = NULL; |
| jmethodID method; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received response to GetWirelessRegulatoryConfig request"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = N2J_WirelessRegulatoryConfig(env, *regConfig, regConfigObj); |
| SuccessOrExit(err); |
| |
| deviceMgrCls = env->GetObjectClass(self); |
| VerifyOrExit(deviceMgrCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(deviceMgrCls, "onGetWirelessRegulatoryConfigComplete", "(Lnl/Weave/DeviceManager/WirelessRegulatoryConfig;)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onGetWirelessRegulatoryConfigComplete method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, regConfigObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| bool HandleCloseConnection(BLE_CONNECTION_OBJECT connObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jmethodID method; |
| bool localFramePushed = false; |
| intptr_t tmpConnObj; |
| bool rc = false; |
| |
| WeaveLogProgress(DeviceManager, "Received CloseConnection"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| method = env->GetStaticMethodID(sWeaveStackCls, "onCloseConnection", "(I)Z"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java CloseConnection"); |
| |
| env->ExceptionClear(); |
| tmpConnObj = reinterpret_cast<intptr_t>(connObj); |
| rc = (bool) env->CallStaticBooleanMethod(sWeaveStackCls, method, static_cast<jint>(tmpConnObj)); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| ReportError(env, err, __FUNCTION__); |
| rc = false; |
| } |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| return rc; |
| } |
| |
| uint16_t HandleGetMTU(BLE_CONNECTION_OBJECT connObj) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jmethodID method; |
| bool localFramePushed = false; |
| intptr_t tmpConnObj; |
| uint16_t mtu = 0; |
| |
| WeaveLogProgress(DeviceManager, "Received GetMTU"); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| method = env->GetStaticMethodID(sWeaveStackCls, "onGetMTU", "(I)I"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onGetMTU"); |
| |
| env->ExceptionClear(); |
| tmpConnObj = reinterpret_cast<intptr_t>(connObj); |
| mtu = (int16_t) env->CallStaticIntMethod(sWeaveStackCls, method, static_cast<jint>(tmpConnObj)); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| ReportError(env, err, __FUNCTION__); |
| mtu = 0; |
| } |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| return mtu; |
| } |
| |
| void HandleGenericError(jobject obj, void *reqState, WEAVE_ERROR deviceErr, DeviceStatus *devStatus) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| JNIEnv *env; |
| jobject self = obj; |
| jclass cls; |
| jmethodID method; |
| jthrowable ex; |
| bool localFramePushed = false; |
| |
| WeaveLogProgress(DeviceManager, "Received error response to %s request", (const char *)reqState); |
| |
| sJVM->GetEnv((void **)&env, JNI_VERSION_1_2); |
| |
| if (env->PushLocalFrame(WDM_JNI_CALLBACK_LOCAL_REF_COUNT) == 0) |
| localFramePushed = true; |
| VerifyOrExit(localFramePushed, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (deviceErr == WEAVE_ERROR_STATUS_REPORT_RECEIVED && devStatus != NULL) |
| { |
| err = N2J_DeviceStatus(env, *devStatus, ex); |
| SuccessOrExit(err); |
| } |
| else |
| { |
| err = N2J_Error(env, deviceErr, ex); |
| SuccessOrExit(err); |
| } |
| |
| cls = env->GetObjectClass(self); |
| VerifyOrExit(cls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| method = env->GetMethodID(cls, "onError", "(Ljava/lang/Throwable;)V"); |
| VerifyOrExit(method != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| WeaveLogProgress(DeviceManager, "Calling Java onError method"); |
| |
| env->ExceptionClear(); |
| env->CallVoidMethod(self, method, ex); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| ReportError(env, err, __FUNCTION__); |
| env->ExceptionClear(); |
| if (localFramePushed) |
| env->PopLocalFrame(NULL); |
| } |
| |
| void HandleError(WeaveDeviceManager *deviceMgr, void *reqState, WEAVE_ERROR deviceErr, DeviceStatus *devStatus) |
| { |
| jobject self = (jobject)deviceMgr->AppState; |
| HandleGenericError(self, reqState, deviceErr, devStatus); |
| } |
| |
| #if WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| void HandleWdmClientError(void *context, void *reqState, WEAVE_ERROR deviceErr, DeviceStatus *devStatus) |
| { |
| WdmClient * wdmClient = reinterpret_cast<WdmClient *>(context); |
| jobject self = (jobject)wdmClient->mpAppState; |
| HandleGenericError(self, reqState, deviceErr, devStatus); |
| } |
| |
| void HandleGenericTraitUpdatableDataSinkError(void *context, void *reqState, WEAVE_ERROR deviceErr, DeviceStatus *devStatus) |
| { |
| GenericTraitUpdatableDataSink * sink = reinterpret_cast<GenericTraitUpdatableDataSink *>(context); |
| jobject self = (jobject)sink->mpAppState; |
| HandleGenericError(self, reqState, deviceErr, devStatus); |
| } |
| #endif // WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| |
| void ThrowError(JNIEnv *env, WEAVE_ERROR errToThrow) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jthrowable ex; |
| |
| err = N2J_Error(env, errToThrow, ex); |
| if (err == WEAVE_NO_ERROR) |
| env->Throw(ex); |
| } |
| |
| void ReportError(JNIEnv *env, WEAVE_ERROR cbErr, const char *functName) |
| { |
| if (cbErr == WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| WeaveLogError(DeviceManager, "Java exception thrown in %s", functName); |
| env->ExceptionDescribe(); |
| } |
| else |
| { |
| const char *errStr; |
| switch (cbErr) |
| { |
| case WDM_JNI_ERROR_TYPE_NOT_FOUND : errStr = "JNI type not found"; break; |
| case WDM_JNI_ERROR_METHOD_NOT_FOUND : errStr = "JNI method not found"; break; |
| case WDM_JNI_ERROR_FIELD_NOT_FOUND : errStr = "JNI field not found"; break; |
| default: ; errStr = nl::ErrorStr(cbErr); break; |
| } |
| WeaveLogError(DeviceManager, "Error in %s : %s", functName, errStr); |
| } |
| } |
| |
| template<typename GetElementFunct> |
| WEAVE_ERROR N2J_GenericArray(JNIEnv *env, uint32_t arrayLen, jclass arrayElemCls, jobjectArray& outArray, GetElementFunct getElem) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jobject elem = NULL; |
| |
| outArray = env->NewObjectArray(arrayLen, arrayElemCls, NULL); |
| VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| for (uint32_t i = 0; i < arrayLen; i++) |
| { |
| err = getElem(env, i, elem); |
| SuccessOrExit(err); |
| |
| env->ExceptionClear(); |
| env->SetObjectArrayElement(outArray, i, elem); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| env->DeleteLocalRef(elem); |
| elem = NULL; |
| } |
| |
| exit: |
| env->DeleteLocalRef(elem); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_ByteArray(JNIEnv *env, jbyteArray inArray, uint8_t *& outArray, uint32_t& outArrayLen) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| outArrayLen = env->GetArrayLength(inArray); |
| |
| outArray = (uint8_t *)malloc(outArrayLen); |
| VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (outArrayLen != 0) |
| { |
| env->ExceptionClear(); |
| env->GetByteArrayRegion(inArray, 0, outArrayLen, (jbyte *)outArray); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| } |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| if (outArray != NULL) |
| { |
| free(outArray); |
| outArray = NULL; |
| } |
| } |
| |
| return err; |
| } |
| |
| // A version of J2N_ByteArray that copies into an existing buffer, rather than allocating memory. |
| WEAVE_ERROR J2N_ByteArrayInPlace(JNIEnv *env, jbyteArray inArray, uint8_t * outArray, uint32_t maxArrayLen) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint32_t arrayLen; |
| |
| VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| arrayLen = env->GetArrayLength(inArray); |
| VerifyOrExit(arrayLen <= maxArrayLen, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| if (arrayLen != 0) |
| { |
| env->ExceptionClear(); |
| env->GetByteArrayRegion(inArray, 0, arrayLen, (jbyte *)outArray); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| } |
| |
| exit: |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_StdString(JNIEnv *env, jstring inString, std::string& outString) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass java_lang_String = NULL; |
| jmethodID ctor = NULL; |
| jbyteArray strJbytes = NULL; |
| const uint8_t *pDataBuf = NULL; |
| size_t length = 0; |
| |
| VerifyOrExit(inString != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| java_lang_String = env->FindClass("java/lang/String"); |
| VerifyOrExit(java_lang_String != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| ctor = env->GetMethodID(java_lang_String, "getBytes", "(Ljava/lang/String;)[B"); |
| VerifyOrExit(ctor != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| strJbytes = (jbyteArray) env->CallObjectMethod(inString, ctor, env->NewStringUTF("UTF-8")); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| length = (size_t) env->GetArrayLength(strJbytes); |
| pDataBuf = (const uint8_t *)env->GetByteArrayElements(strJbytes, NULL); |
| |
| outString.append((char *)pDataBuf, length); |
| |
| exit: |
| if (strJbytes != NULL) |
| { |
| env->ReleaseByteArrayElements(strJbytes, (jbyte* )pDataBuf, JNI_ABORT); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| env->DeleteLocalRef(strJbytes); |
| env->DeleteLocalRef(java_lang_String); |
| return err; |
| } |
| |
| WEAVE_ERROR N2J_ByteArray(JNIEnv *env, const uint8_t *inArray, uint32_t inArrayLen, jbyteArray& outArray) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| outArray = env->NewByteArray((int)inArrayLen); |
| VerifyOrExit(outArray != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| env->ExceptionClear(); |
| env->SetByteArrayRegion(outArray, 0, inArrayLen, (jbyte *)inArray); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| return err; |
| } |
| |
| WEAVE_ERROR N2J_NewStringUTF(JNIEnv *env, const char *inStr, jstring& outString) |
| { |
| return N2J_NewStringUTF(env, inStr, strlen(inStr), outString); |
| } |
| |
| WEAVE_ERROR N2J_NewStringUTF(JNIEnv *env, const char *inStr, size_t inStrLen, jstring& outString) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jbyteArray charArray = NULL; |
| jstring utf8Encoding = NULL; |
| jclass java_lang_String = NULL; |
| jmethodID ctor = NULL; |
| |
| err = N2J_ByteArray(env, reinterpret_cast<const uint8_t *>(inStr), inStrLen, charArray); |
| SuccessOrExit(err); |
| |
| utf8Encoding = env->NewStringUTF("UTF-8"); |
| VerifyOrExit(utf8Encoding != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| java_lang_String = env->FindClass("java/lang/String"); |
| VerifyOrExit(java_lang_String != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| ctor = env->GetMethodID(java_lang_String, "<init>", "([BLjava/lang/String;)V"); |
| VerifyOrExit(ctor != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| outString = (jstring) env->NewObject(java_lang_String, ctor, charArray, utf8Encoding); |
| VerifyOrExit(outString != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| exit: |
| // error code propagated from here, so clear any possible |
| // exceptions that arose here |
| env->ExceptionClear(); |
| |
| if (utf8Encoding != NULL) |
| env->DeleteLocalRef(utf8Encoding); |
| if (charArray != NULL) |
| env->DeleteLocalRef(charArray); |
| |
| return err; |
| } |
| |
| #if CURRENTLY_UNUSED |
| |
| WEAVE_ERROR J2N_EnumVal(JNIEnv *env, jobject enumObj, int& outVal) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass enumCls = NULL; |
| jfieldID fieldId; |
| |
| enumCls = env->GetObjectClass(enumObj); |
| VerifyOrExit(enumCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| fieldId = env->GetFieldID(enumCls, "val", "I"); |
| VerifyOrExit(fieldId != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| outVal = env->GetIntField(enumObj, fieldId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(enumCls); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_IntFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jint& outVal) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass objCls = NULL; |
| jfieldID fieldId; |
| |
| objCls = env->GetObjectClass(obj); |
| VerifyOrExit(objCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| fieldId = env->GetFieldID(objCls, fieldName, "I"); |
| VerifyOrExit(fieldId != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| outVal = env->GetIntField(obj, fieldId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(objCls); |
| return err; |
| } |
| |
| #endif // CURRENTLY_UNUSED |
| |
| WEAVE_ERROR J2N_EnumFieldVal(JNIEnv *env, jobject obj, const char *fieldName, const char *fieldType, int& outVal) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass objCls = NULL, enumCls = NULL; |
| jfieldID fieldId; |
| jobject enumObj = NULL; |
| |
| objCls = env->GetObjectClass(obj); |
| VerifyOrExit(objCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| fieldId = env->GetFieldID(objCls, fieldName, fieldType); |
| VerifyOrExit(fieldId != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| enumObj = env->GetObjectField(obj, fieldId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| if (enumObj != NULL) |
| { |
| enumCls = env->GetObjectClass(enumObj); |
| VerifyOrExit(enumCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| fieldId = env->GetFieldID(enumCls, "val", "I"); |
| VerifyOrExit(fieldId != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| outVal = env->GetIntField(enumObj, fieldId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| } |
| else |
| outVal = -1; |
| |
| exit: |
| env->DeleteLocalRef(enumCls); |
| env->DeleteLocalRef(enumObj); |
| env->DeleteLocalRef(objCls); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_ShortFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jshort& outVal) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass objCls = NULL; |
| jfieldID fieldId; |
| |
| objCls = env->GetObjectClass(obj); |
| VerifyOrExit(objCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| fieldId = env->GetFieldID(objCls, fieldName, "S"); |
| VerifyOrExit(fieldId != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| outVal = env->GetShortField(obj, fieldId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(objCls); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_IntFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jint& outVal) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass objCls = NULL; |
| jfieldID fieldId; |
| |
| objCls = env->GetObjectClass(obj); |
| VerifyOrExit(objCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| fieldId = env->GetFieldID(objCls, fieldName, "I"); |
| VerifyOrExit(fieldId != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| outVal = env->GetIntField(obj, fieldId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(objCls); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_LongFieldVal(JNIEnv *env, jobject obj, const char *fieldName, jlong& outVal) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass objCls = NULL; |
| jfieldID fieldId; |
| |
| objCls = env->GetObjectClass(obj); |
| VerifyOrExit(objCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| fieldId = env->GetFieldID(objCls, fieldName, "J"); |
| VerifyOrExit(fieldId != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| outVal = env->GetLongField(obj, fieldId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(objCls); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_StringFieldVal(JNIEnv *env, jobject obj, const char *fieldName, char *& outVal) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass objCls = NULL; |
| jfieldID fieldId; |
| jstring strObj = NULL; |
| const char *nativeStr; |
| |
| objCls = env->GetObjectClass(obj); |
| VerifyOrExit(objCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| fieldId = env->GetFieldID(objCls, fieldName, "Ljava/lang/String;"); |
| VerifyOrExit(fieldId != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| strObj = (jstring)env->GetObjectField(obj, fieldId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| if (strObj != NULL) |
| { |
| nativeStr = env->GetStringUTFChars(strObj, 0); |
| outVal = strdup(nativeStr); |
| env->ReleaseStringUTFChars(strObj, nativeStr); |
| } |
| else |
| outVal = NULL; |
| |
| exit: |
| env->DeleteLocalRef(strObj); |
| env->DeleteLocalRef(objCls); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_ByteArrayFieldVal(JNIEnv *env, jobject obj, const char *fieldName, uint8_t *& outArray, uint32_t& outArrayLen) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass objCls = NULL; |
| jfieldID fieldId; |
| jbyteArray byteArrayObj = NULL; |
| |
| objCls = env->GetObjectClass(obj); |
| VerifyOrExit(objCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| fieldId = env->GetFieldID(objCls, fieldName, "[B"); |
| VerifyOrExit(fieldId != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| byteArrayObj = (jbyteArray)env->GetObjectField(obj, fieldId); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| if (byteArrayObj != NULL) |
| { |
| err = J2N_ByteArray(env, byteArrayObj, outArray, outArrayLen); |
| SuccessOrExit(err); |
| } |
| else |
| { |
| outArray = NULL; |
| outArrayLen = 0; |
| } |
| |
| exit: |
| env->DeleteLocalRef(byteArrayObj); |
| env->DeleteLocalRef(objCls); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_IdentifyDeviceCriteria(JNIEnv *env, jobject inCriteria, IdentifyDeviceCriteria& outCriteria) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jlong longVal; |
| jint intVal; |
| int enumVal; |
| |
| err = J2N_LongFieldVal(env, inCriteria, "TargetFabricId", longVal); |
| SuccessOrExit(err); |
| outCriteria.TargetFabricId = (uint64_t)longVal; |
| |
| err = J2N_EnumFieldVal(env, inCriteria, "TargetModes", "Lnl/Weave/DeviceManager/TargetDeviceModes;", enumVal); |
| SuccessOrExit(err); |
| outCriteria.TargetModes = (uint32_t)enumVal; |
| |
| err = J2N_IntFieldVal(env, inCriteria, "TargetVendorId", intVal); |
| SuccessOrExit(err); |
| outCriteria.TargetVendorId = (uint16_t)intVal; |
| |
| err = J2N_IntFieldVal(env, inCriteria, "TargetProductId", intVal); |
| SuccessOrExit(err); |
| outCriteria.TargetProductId = (uint16_t)intVal; |
| |
| err = J2N_LongFieldVal(env, inCriteria, "TargetDeviceId", longVal); |
| SuccessOrExit(err); |
| outCriteria.TargetDeviceId = (uint64_t)longVal; |
| |
| exit: |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_NetworkInfo(JNIEnv *env, jobject inNetworkInfo, NetworkInfo& outNetworkInfo) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jlong longVal; |
| jint intVal; |
| jshort shortVal; |
| uint32_t len; |
| int enumVal; |
| |
| err = J2N_EnumFieldVal(env, inNetworkInfo, "NetworkType", "Lnl/Weave/DeviceManager/NetworkType;", enumVal); |
| SuccessOrExit(err); |
| outNetworkInfo.NetworkType = (NetworkProvisioning::NetworkType)enumVal; |
| |
| err = J2N_LongFieldVal(env, inNetworkInfo, "NetworkId", longVal); |
| SuccessOrExit(err); |
| outNetworkInfo.NetworkId = longVal; |
| |
| err = J2N_StringFieldVal(env, inNetworkInfo, "WiFiSSID", outNetworkInfo.WiFiSSID); |
| SuccessOrExit(err); |
| |
| err = J2N_EnumFieldVal(env, inNetworkInfo, "WiFiMode", "Lnl/Weave/DeviceManager/WiFiMode;", enumVal); |
| SuccessOrExit(err); |
| outNetworkInfo.WiFiMode = (NetworkProvisioning::WiFiMode)enumVal; |
| |
| err = J2N_EnumFieldVal(env, inNetworkInfo, "WiFiRole", "Lnl/Weave/DeviceManager/WiFiRole;", enumVal); |
| SuccessOrExit(err); |
| outNetworkInfo.WiFiRole = (NetworkProvisioning::WiFiRole)enumVal; |
| |
| err = J2N_EnumFieldVal(env, inNetworkInfo, "WiFiSecurityType", "Lnl/Weave/DeviceManager/WiFiSecurityType;", enumVal); |
| SuccessOrExit(err); |
| outNetworkInfo.WiFiSecurityType = (NetworkProvisioning::WiFiSecurityType)enumVal; |
| |
| err = J2N_ByteArrayFieldVal(env, inNetworkInfo, "WiFiKey", outNetworkInfo.WiFiKey, outNetworkInfo.WiFiKeyLen); |
| SuccessOrExit(err); |
| |
| err = J2N_StringFieldVal(env, inNetworkInfo, "ThreadNetworkName", outNetworkInfo.ThreadNetworkName); |
| SuccessOrExit(err); |
| |
| err = J2N_ByteArrayFieldVal(env, inNetworkInfo, "ThreadExtendedPANId", outNetworkInfo.ThreadExtendedPANId, len); |
| SuccessOrExit(err); |
| if (outNetworkInfo.ThreadExtendedPANId != NULL && len != NetworkInfo::kThreadExtendedPANIdLength) |
| ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| err = J2N_ByteArrayFieldVal(env, inNetworkInfo, "ThreadNetworkKey", outNetworkInfo.ThreadNetworkKey, len); |
| SuccessOrExit(err); |
| if (outNetworkInfo.ThreadNetworkKey != NULL && len != NetworkInfo::kThreadNetworkKeyLength) |
| ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| err = J2N_ByteArrayFieldVal(env, inNetworkInfo, "ThreadPSKc", outNetworkInfo.ThreadPSKc, len); |
| SuccessOrExit(err); |
| if (outNetworkInfo.ThreadPSKc!= NULL && len != NetworkInfo::kThreadPSKcLength) |
| ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| err = J2N_IntFieldVal(env, inNetworkInfo, "ThreadPANId", intVal); |
| SuccessOrExit(err); |
| outNetworkInfo.ThreadPANId = intVal; |
| |
| err = J2N_IntFieldVal(env, inNetworkInfo, "ThreadChannel", intVal); |
| SuccessOrExit(err); |
| outNetworkInfo.ThreadChannel = intVal; |
| |
| err = J2N_ShortFieldVal(env, inNetworkInfo, "WirelessSignalStrength", shortVal); |
| SuccessOrExit(err); |
| outNetworkInfo.WirelessSignalStrength = shortVal; |
| |
| exit: |
| return err; |
| } |
| |
| WEAVE_ERROR N2J_NetworkInfo(JNIEnv *env, const NetworkInfo& inNetworkInfo, jobject& outNetworkInfo) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jmethodID makeMethod; |
| jstring wifiSSID = NULL; |
| jbyteArray wifiKey = NULL; |
| jstring threadNetName = NULL; |
| jbyteArray threadExtPANId = NULL; |
| jbyteArray threadKey = NULL; |
| jbyteArray threadPSKc = NULL; |
| |
| if (inNetworkInfo.WiFiSSID != NULL) |
| { |
| err = N2J_NewStringUTF(env, inNetworkInfo.WiFiSSID, wifiSSID); |
| SuccessOrExit(err); |
| } |
| |
| if (inNetworkInfo.WiFiKey != NULL) |
| { |
| err = N2J_ByteArray(env, inNetworkInfo.WiFiKey, inNetworkInfo.WiFiKeyLen, wifiKey); |
| SuccessOrExit(err); |
| } |
| |
| if (inNetworkInfo.ThreadNetworkName != NULL) |
| { |
| err = N2J_NewStringUTF(env, inNetworkInfo.ThreadNetworkName, threadNetName); |
| SuccessOrExit(err); |
| } |
| |
| if (inNetworkInfo.ThreadExtendedPANId != NULL) |
| { |
| err = N2J_ByteArray(env, inNetworkInfo.ThreadExtendedPANId, NetworkInfo::kThreadExtendedPANIdLength, threadExtPANId); |
| SuccessOrExit(err); |
| } |
| |
| if (inNetworkInfo.ThreadNetworkKey != NULL) |
| { |
| err = N2J_ByteArray(env, inNetworkInfo.ThreadNetworkKey, NetworkInfo::kThreadNetworkKeyLength, threadKey); |
| SuccessOrExit(err); |
| } |
| |
| if (inNetworkInfo.ThreadPSKc != NULL) |
| { |
| err = N2J_ByteArray(env, inNetworkInfo.ThreadPSKc, NetworkInfo::kThreadPSKcLength, threadPSKc); |
| SuccessOrExit(err); |
| } |
| |
| makeMethod = env->GetStaticMethodID(sNetworkInfoCls, "Make", "(IJLjava/lang/String;III[BLjava/lang/String;[B[B[BSII)Lnl/Weave/DeviceManager/NetworkInfo;"); |
| VerifyOrExit(makeMethod != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| outNetworkInfo = env->CallStaticObjectMethod(sNetworkInfoCls, makeMethod, |
| (jint)inNetworkInfo.NetworkType, |
| (jlong)inNetworkInfo.NetworkId, |
| wifiSSID, |
| (jint)inNetworkInfo.WiFiMode, |
| (jint)inNetworkInfo.WiFiRole, |
| (jint)inNetworkInfo.WiFiSecurityType, |
| wifiKey, |
| threadNetName, |
| threadExtPANId, |
| threadKey, |
| threadPSKc, |
| (jshort)inNetworkInfo.WirelessSignalStrength, |
| (jint)inNetworkInfo.ThreadPANId, |
| (jint)inNetworkInfo.ThreadChannel); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(threadKey); |
| env->DeleteLocalRef(threadExtPANId); |
| env->DeleteLocalRef(threadNetName); |
| env->DeleteLocalRef(wifiKey); |
| env->DeleteLocalRef(wifiSSID); |
| return err; |
| } |
| |
| WEAVE_ERROR N2J_NetworkInfoArray(JNIEnv *env, const NetworkInfo *inArray, uint32_t inArrayLen, jobjectArray& outArray) |
| { |
| return N2J_GenericArray(env, inArrayLen, sNetworkInfoCls, outArray, |
| [&](JNIEnv * _env, uint32_t index, jobject& _outElem) -> WEAVE_ERROR |
| { |
| return N2J_NetworkInfo(_env, inArray[index], _outElem); |
| }); |
| } |
| |
| WEAVE_ERROR N2J_DeviceDescriptor(JNIEnv *env, const WeaveDeviceDescriptor& inDeviceDesc, jobject& outDeviceDesc) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jmethodID constructor; |
| jbyteArray primary802154MACAddress = NULL; |
| jbyteArray primaryWiFiMACAddress = NULL; |
| jstring serialNumber = NULL; |
| jstring rendezvousWiFiESSID = NULL; |
| jstring pairingCode = NULL; |
| jstring softwareVersion = NULL; |
| |
| if (!WeaveDeviceDescriptor::IsZeroBytes(inDeviceDesc.Primary802154MACAddress, sizeof(inDeviceDesc.Primary802154MACAddress))) |
| { |
| err = N2J_ByteArray(env, inDeviceDesc.Primary802154MACAddress, sizeof(inDeviceDesc.Primary802154MACAddress), primary802154MACAddress); |
| SuccessOrExit(err); |
| } |
| |
| if (!WeaveDeviceDescriptor::IsZeroBytes(inDeviceDesc.PrimaryWiFiMACAddress, sizeof(inDeviceDesc.PrimaryWiFiMACAddress))) |
| { |
| err = N2J_ByteArray(env, inDeviceDesc.PrimaryWiFiMACAddress, sizeof(inDeviceDesc.PrimaryWiFiMACAddress), primaryWiFiMACAddress); |
| SuccessOrExit(err); |
| } |
| |
| if (inDeviceDesc.SerialNumber[0] != 0) |
| { |
| err = N2J_NewStringUTF(env, inDeviceDesc.SerialNumber, serialNumber); |
| SuccessOrExit(err); |
| } |
| |
| if (inDeviceDesc.RendezvousWiFiESSID[0] != 0) |
| { |
| err = N2J_NewStringUTF(env, inDeviceDesc.RendezvousWiFiESSID, rendezvousWiFiESSID); |
| SuccessOrExit(err); |
| } |
| |
| if (inDeviceDesc.PairingCode[0] != 0) |
| { |
| err = N2J_NewStringUTF(env, inDeviceDesc.PairingCode, pairingCode); |
| SuccessOrExit(err); |
| } |
| |
| if (inDeviceDesc.SoftwareVersion[0] != 0) |
| { |
| err = N2J_NewStringUTF(env, inDeviceDesc.SoftwareVersion, softwareVersion); |
| SuccessOrExit(err); |
| } |
| |
| constructor = env->GetMethodID(sWeaveDeviceDescriptorCls, "<init>", "(IIIIII[B[BLjava/lang/String;Ljava/lang/String;Ljava/lang/String;JJLjava/lang/String;IIII)V"); |
| VerifyOrExit(constructor != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| outDeviceDesc = (jthrowable)env->NewObject(sWeaveDeviceDescriptorCls, constructor, |
| inDeviceDesc.VendorId, inDeviceDesc.ProductId, inDeviceDesc.ProductRevision, |
| inDeviceDesc.ManufacturingDate.Year, inDeviceDesc.ManufacturingDate.Month, inDeviceDesc.ManufacturingDate.Day, |
| primary802154MACAddress, primaryWiFiMACAddress, |
| serialNumber, rendezvousWiFiESSID, pairingCode, |
| (jlong)inDeviceDesc.DeviceId, (jlong)inDeviceDesc.FabricId, softwareVersion, |
| (jint)inDeviceDesc.PairingCompatibilityVersionMajor, |
| (jint)inDeviceDesc.PairingCompatibilityVersionMinor, |
| (jint)inDeviceDesc.DeviceFeatures, (jint)inDeviceDesc.Flags); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(softwareVersion); |
| env->DeleteLocalRef(pairingCode); |
| env->DeleteLocalRef(rendezvousWiFiESSID); |
| env->DeleteLocalRef(serialNumber); |
| env->DeleteLocalRef(primaryWiFiMACAddress); |
| env->DeleteLocalRef(primary802154MACAddress); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_WirelessRegulatoryConfig(JNIEnv *env, jobject inRegConfig, WirelessRegConfig & outRegConfig) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| int enumVal; |
| char * strVal = NULL; |
| |
| outRegConfig.Init(); |
| |
| err = J2N_StringFieldVal(env, inRegConfig, "RegDomain", strVal); |
| SuccessOrExit(err); |
| |
| // If present, RegDomain must be exactly 2 characters long. |
| if (strVal != NULL) |
| { |
| VerifyOrExit(strlen(strVal) == sizeof(outRegConfig.RegDomain.Code), err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| memcpy(outRegConfig.RegDomain.Code, strVal, sizeof(outRegConfig.RegDomain.Code)); |
| } |
| |
| err = J2N_EnumFieldVal(env, inRegConfig, "OpLocation", "Lnl/Weave/DeviceManager/WirelessOperatingLocation;", enumVal); |
| SuccessOrExit(err); |
| outRegConfig.OpLocation = (uint8_t)enumVal; |
| |
| // NOTE: The SupportRegulatoryDomains field is never sent *to* a device. Thus we ignore the field value here. |
| |
| exit: |
| if (strVal != NULL) |
| { |
| free(strVal); |
| } |
| return err; |
| } |
| |
| WEAVE_ERROR N2J_WirelessRegulatoryConfig(JNIEnv *env, const WirelessRegConfig& inRegConfig, jobject& outRegConfig) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jmethodID constructor; |
| jstring regDomain = NULL; |
| jobjectArray supportedRegDomains = NULL; |
| jclass java_lang_String = NULL; |
| |
| if (inRegConfig.IsRegDomainPresent()) |
| { |
| err = N2J_NewStringUTF(env, inRegConfig.RegDomain.Code, sizeof(inRegConfig.RegDomain.Code), regDomain); |
| SuccessOrExit(err); |
| } |
| |
| java_lang_String = env->FindClass("java/lang/String"); |
| VerifyOrExit(java_lang_String != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| err = N2J_GenericArray(env, inRegConfig.NumSupportedRegDomains, java_lang_String, supportedRegDomains, |
| [&inRegConfig](JNIEnv *_env, uint32_t index, jobject& outElem) -> WEAVE_ERROR |
| { |
| jstring strElem = NULL; |
| WEAVE_ERROR _err = N2J_NewStringUTF(_env, inRegConfig.SupportedRegDomains[index].Code, sizeof(WirelessRegDomain::Code), strElem); |
| outElem = strElem; |
| return _err; |
| }); |
| SuccessOrExit(err); |
| |
| constructor = env->GetMethodID(sWirelessRegulatoryConfigCls, "<init>", "(Ljava/lang/String;I[Ljava/lang/String;)V"); |
| VerifyOrExit(constructor != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| env->ExceptionClear(); |
| outRegConfig = (jthrowable)env->NewObject(sWirelessRegulatoryConfigCls, constructor, |
| regDomain, (jint)inRegConfig.OpLocation, supportedRegDomains); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(regDomain); |
| env->DeleteLocalRef(supportedRegDomains); |
| return err; |
| } |
| |
| WEAVE_ERROR N2J_Error(JNIEnv *env, WEAVE_ERROR inErr, jthrowable& outEx) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jmethodID constructor; |
| const char *errStr = NULL; |
| jstring errStrObj = NULL; |
| |
| constructor = env->GetMethodID(sWeaveDeviceManagerExceptionCls, "<init>", "(ILjava/lang/String;)V"); |
| VerifyOrExit(constructor != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| switch (inErr) |
| { |
| case WDM_JNI_ERROR_TYPE_NOT_FOUND : errStr = "Weave Device Manager Error: JNI type not found"; break; |
| case WDM_JNI_ERROR_METHOD_NOT_FOUND : errStr = "Weave Device Manager Error: JNI method not found"; break; |
| case WDM_JNI_ERROR_FIELD_NOT_FOUND : errStr = "Weave Device Manager Error: JNI field not found"; break; |
| default: ; errStr = nl::ErrorStr(inErr); break; |
| } |
| errStrObj = (errStr != NULL) ? env->NewStringUTF(errStr) : NULL; |
| |
| env->ExceptionClear(); |
| outEx = (jthrowable)env->NewObject(sWeaveDeviceManagerExceptionCls, constructor, (jint)inErr, errStrObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(errStrObj); |
| return err; |
| } |
| |
| WEAVE_ERROR N2J_DeviceStatus(JNIEnv *env, DeviceStatus& devStatus, jthrowable& outEx) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jmethodID constructor; |
| const char *errStr = NULL; |
| jstring errStrObj = NULL; |
| |
| constructor = env->GetMethodID(sWeaveDeviceExceptionCls, "<init>", "(IIILjava/lang/String;)V"); |
| VerifyOrExit(constructor != NULL, err = WDM_JNI_ERROR_METHOD_NOT_FOUND); |
| |
| errStr = nl::StatusReportStr(devStatus.StatusProfileId, devStatus.StatusCode); |
| errStrObj = (errStr != NULL) ? env->NewStringUTF(errStr) : NULL; |
| |
| env->ExceptionClear(); |
| outEx = (jthrowable)env->NewObject(sWeaveDeviceExceptionCls, constructor, (jint)devStatus.StatusCode, (jint)devStatus.StatusProfileId, (jint)devStatus.SystemErrorCode, errStrObj); |
| VerifyOrExit(!env->ExceptionCheck(), err = WDM_JNI_ERROR_EXCEPTION_THROWN); |
| |
| exit: |
| env->DeleteLocalRef(errStrObj); |
| return err; |
| } |
| |
| WEAVE_ERROR J2N_ResourceIdentifier(JNIEnv *env, jobject inResourceIdentifier, ResourceIdentifier & outResourceIdentifier) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jlong longVal = 0; |
| int intVal; |
| |
| err = J2N_IntFieldVal(env, inResourceIdentifier, "resourceType", intVal); |
| SuccessOrExit(err); |
| |
| err = J2N_LongFieldVal(env, inResourceIdentifier, "resourceId", longVal); |
| SuccessOrExit(err); |
| |
| outResourceIdentifier = ResourceIdentifier(intVal, (uint64_t) longVal); |
| exit: |
| return err; |
| } |
| |
| WEAVE_ERROR GetClassRef(JNIEnv *env, const char *clsType, jclass& outCls) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jclass cls = NULL; |
| |
| cls = env->FindClass(clsType); |
| VerifyOrExit(cls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| outCls = (jclass)env->NewGlobalRef((jobject)cls); |
| VerifyOrExit(outCls != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| exit: |
| env->DeleteLocalRef(cls); |
| return err; |
| } |
| |
| #if WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| void EngineEventCallback(void * const aAppState, |
| SubscriptionEngine::EventID aEvent, |
| const SubscriptionEngine::InEventParam & aInParam, SubscriptionEngine::OutEventParam & aOutParam) |
| { |
| switch (aEvent) |
| { |
| default: |
| SubscriptionEngine::DefaultEventHandler(aEvent, aInParam, aOutParam); |
| break; |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_WdmClientImpl_init(JNIEnv *env, jobject self) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| err = SubscriptionEngine::GetInstance()->Init(&sExchangeMgr, NULL, EngineEventCallback); |
| SuccessOrExit(err); |
| |
| exit: |
| return; |
| } |
| |
| void BindingEventCallback (void * const apAppState, const nl::Weave::Binding::EventType aEvent, |
| const nl::Weave::Binding::InEventParam & aInParam, nl::Weave::Binding::OutEventParam & aOutParam) |
| { |
| WeaveLogDetail(DeviceManager, "%s: Event(%d)", __func__, aEvent); |
| switch (aEvent) |
| { |
| case nl::Weave::Binding::kEvent_PrepareRequested: |
| WeaveLogDetail(DeviceManager, "kEvent_PrepareRequested"); |
| break; |
| |
| case nl::Weave::Binding::kEvent_PrepareFailed: |
| WeaveLogDetail(DeviceManager, "kEvent_PrepareFailed: reason %s", ::nl::ErrorStr(aInParam.PrepareFailed.Reason)); |
| break; |
| |
| case nl::Weave::Binding::kEvent_BindingFailed: |
| WeaveLogDetail(DeviceManager, "kEvent_BindingFailed: reason %s", ::nl::ErrorStr(aInParam.PrepareFailed.Reason)); |
| break; |
| |
| case nl::Weave::Binding::kEvent_BindingReady: |
| WeaveLogDetail(DeviceManager, "kEvent_BindingReady"); |
| break; |
| |
| case nl::Weave::Binding::kEvent_DefaultCheck: |
| WeaveLogDetail(DeviceManager, "kEvent_DefaultCheck"); |
| // fall through |
| default: |
| nl::Weave::Binding::DefaultEventHandler(apAppState, aEvent, aInParam, aOutParam); |
| } |
| } |
| |
| jlong Java_nl_Weave_DataManagement_WdmClientImpl_newWdmClient(JNIEnv *env, jobject self, jlong deviceMgrPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| long res = 0; |
| WdmClient *wdmClient = NULL; |
| Binding * pBinding = NULL; |
| WeaveDeviceManager *deviceMgr = (WeaveDeviceManager *)deviceMgrPtr; |
| |
| WeaveLogProgress(DeviceManager, "NewWdmClient() called"); |
| |
| pBinding = sExchangeMgr.NewBinding(BindingEventCallback, deviceMgr); |
| VerifyOrExit(NULL != pBinding, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = deviceMgr->ConfigureBinding(pBinding); |
| SuccessOrExit(err); |
| |
| wdmClient = new WdmClient(); |
| VerifyOrExit(wdmClient != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = wdmClient->Init(&MessageLayer, pBinding); |
| SuccessOrExit(err); |
| |
| wdmClient->mpAppState = (void *)env->NewGlobalRef(self); |
| |
| res = (long)wdmClient; |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| { |
| if (wdmClient != NULL) |
| { |
| if (wdmClient->mpAppState != NULL) |
| { |
| env->DeleteGlobalRef((jobject)wdmClient->mpAppState); |
| } |
| wdmClient->Close(); |
| delete wdmClient; |
| } |
| } |
| |
| if (NULL != pBinding) |
| { |
| pBinding->Release(); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| return res; |
| } |
| |
| void Java_nl_Weave_DataManagement_WdmClientImpl_deleteWdmClient(JNIEnv *env, jobject self, jlong wdmClientPtr) |
| { |
| WdmClient *wdmClient = (WdmClient *)wdmClientPtr; |
| |
| WeaveLogProgress(DeviceManager, "DeleteWdmClient() called"); |
| |
| if (wdmClient != NULL) |
| { |
| if (wdmClient->mpAppState != NULL) |
| { |
| env->DeleteGlobalRef((jobject)wdmClient->mpAppState); |
| } |
| wdmClient->Close(); |
| delete wdmClient; |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_WdmClientImpl_setNodeId(JNIEnv *env, jobject self, jlong wdmClientPtr, jlong nodeId) |
| { |
| WdmClient *wdmClient = (WdmClient *)wdmClientPtr; |
| WeaveLogProgress(DeviceManager, "setNodeId() called"); |
| wdmClient->SetNodeId((uint64_t)nodeId); |
| } |
| |
| jlong Java_nl_Weave_DataManagement_WdmClientImpl_newDataSink(JNIEnv *env, jobject self, jlong wdmClientPtr, jobject resourceIdentifierObj, jlong profileId, jlong instanceId, jstring path) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| long res = 0; |
| const char *pPathStr = NULL; |
| ResourceIdentifier resourceIdentifier; |
| GenericTraitUpdatableDataSink * dataSink = NULL; |
| WdmClient *wdmClient = (WdmClient *)wdmClientPtr; |
| |
| WeaveLogProgress(DeviceManager, "newDataSink() called"); |
| |
| err = J2N_ResourceIdentifier(env, resourceIdentifierObj, resourceIdentifier); |
| SuccessOrExit(err); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = wdmClient->NewDataSink(resourceIdentifier, (uint32_t)profileId, (uint64_t)instanceId, pPathStr, dataSink); |
| |
| exit: |
| if (err == WEAVE_NO_ERROR && dataSink != NULL) |
| { |
| res = (long) dataSink; |
| } |
| |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| return res; |
| } |
| |
| void Java_nl_Weave_DataManagement_WdmClientImpl_beginFlushUpdate(JNIEnv *env, jobject self, jlong wdmClientPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WdmClient *wdmClient = (WdmClient *)wdmClientPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginFlushUpdate() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| err = wdmClient->FlushUpdate((void *)"FlushUpdate", HandleWdmClientComplete, HandleWdmClientError); |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_WdmClientImpl_beginRefreshData(JNIEnv *env, jobject self, jlong wdmClientPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| WdmClient *wdmClient = (WdmClient *)wdmClientPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginRefreshData() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| err = wdmClient->RefreshData((void *)"RefreshData", HandleWdmClientComplete, HandleWdmClientError, NULL); |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_init(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr) |
| { |
| GenericTraitUpdatableDataSink *pDataSink = NULL; |
| pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "Init() called"); |
| |
| pDataSink->mpAppState = (void *)env->NewGlobalRef(self); |
| |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_shutdown(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr) |
| { |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "shutdown() called"); |
| |
| if (pDataSink != NULL) |
| { |
| if (pDataSink->mpAppState != NULL) |
| { |
| env->DeleteGlobalRef((jobject)pDataSink->mpAppState); |
| } |
| pDataSink->Clear(); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_clear(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr) |
| { |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "clear() called"); |
| |
| if (pDataSink != NULL) |
| { |
| pDataSink->Clear(); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_beginRefreshData(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "beginRefreshData() called"); |
| |
| pthread_mutex_lock(&sStackLock); |
| err = pDataSink->RefreshData((void *)"RefreshData", HandleGenericTraitUpdatableDataSinkComplete, HandleGenericTraitUpdatableDataSinkError); |
| pthread_mutex_unlock(&sStackLock); |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setInt(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jlong value, jboolean isConditional, jboolean isSigned) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const char *pPathStr = NULL; |
| |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "setInt() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| if (isSigned == JNI_TRUE) |
| { |
| int64_t signedValue = (int64_t)value; |
| err = pDataSink->SetData(pPathStr, signedValue, isConditional == JNI_TRUE); |
| } |
| else |
| { |
| uint64_t unsignedValue = (uint64_t)value; |
| err = pDataSink->SetData(pPathStr, unsignedValue, isConditional == JNI_TRUE); |
| } |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setDouble(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jdouble value, jboolean isConditional) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const char *pPathStr = NULL; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "setDouble() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->SetData(pPathStr, value, isConditional == JNI_TRUE); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setBoolean(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jboolean value, jboolean isConditional) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const char *pPathStr = NULL; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "setBoolean() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->SetBoolean(pPathStr, value == JNI_TRUE, isConditional == JNI_TRUE); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setString(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jstring value, jboolean isConditional) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const char *pPathStr = NULL; |
| const char *pValue = NULL; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "setString() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| pValue = env->GetStringUTFChars(value, 0); |
| VerifyOrExit(pValue != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->SetString(pPathStr, pValue, isConditional == JNI_TRUE); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (pValue != NULL) |
| { |
| env->ReleaseStringUTFChars(value, pValue); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setNull(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jboolean isConditional) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const char *pPathStr = NULL; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "setNull() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->SetNull(pPathStr, isConditional == JNI_TRUE); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setBytes(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jbyteArray value, jboolean isConditional) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const char *pPathStr = NULL; |
| const uint8_t *pDataBuf = NULL; |
| uint32_t dataLen; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "setBytes() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| dataLen = env->GetArrayLength(value); |
| pDataBuf = (const uint8_t *)env->GetByteArrayElements(value, NULL); |
| |
| err = pDataSink->SetBytes(pPathStr, pDataBuf, dataLen, isConditional == JNI_TRUE); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (pDataBuf != NULL) |
| { |
| env->ReleaseByteArrayElements(value, (jbyte *)pDataBuf, JNI_ABORT); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| void Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_setStringArray(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path, jobjectArray stringArray, jboolean isConditional) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const char *pPathStr = NULL; |
| jstring jst = NULL; |
| std::vector<std::string> stringVector; |
| int stringCount = env->GetArrayLength(stringArray); |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "setStringArray() called"); |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| for (int i=0; i < stringCount; i++) |
| { |
| std::string val; |
| jst = (jstring) (env->GetObjectArrayElement(stringArray, i)); |
| err = J2N_StdString(env, jst, val); |
| SuccessOrExit(err); |
| stringVector.push_back(val); |
| } |
| |
| err = pDataSink->SetStringArray(pPathStr, stringVector, isConditional == JNI_TRUE); |
| |
| exit: |
| env->DeleteLocalRef(jst); |
| |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| } |
| |
| jlong Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getLong(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint64_t value = 0; |
| const char *pPathStr = NULL; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "getLong() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->GetData(pPathStr, value); |
| SuccessOrExit(err); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| return (int64_t)value; |
| |
| } |
| |
| jdouble Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getDouble(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| double value = 0; |
| const char *pPathStr = NULL; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "getDouble() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->GetData(pPathStr, value); |
| SuccessOrExit(err); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| return value; |
| } |
| |
| jboolean Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getBoolean(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| bool value = true; |
| jboolean jValue = JNI_TRUE; |
| const char *pPathStr = NULL; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "getBoolean() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->GetBoolean(pPathStr, value); |
| SuccessOrExit(err); |
| |
| if (!value) |
| { |
| jValue = JNI_FALSE; |
| } |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| return jValue; |
| } |
| |
| jstring Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getString(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const char *pPathStr = NULL; |
| BytesData bytesData; |
| std::string valueStr; |
| |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "getString() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->GetString(pPathStr, &bytesData); |
| SuccessOrExit(err); |
| |
| valueStr = std::string((char *)(bytesData.mpDataBuf), bytesData.mDataLen); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| return env->NewStringUTF(valueStr.c_str()); |
| } |
| |
| jbyteArray Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getBytes(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| jbyteArray value = NULL; |
| const char *pPathStr = NULL; |
| BytesData bytesData; |
| |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "getByte() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->GetBytes(pPathStr, &bytesData); |
| SuccessOrExit(err); |
| |
| err = N2J_ByteArray(env, bytesData.mpDataBuf, bytesData.mDataLen, value); |
| SuccessOrExit(err); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| return value; |
| } |
| |
| jobjectArray Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getStringArray(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| const char *pPathStr = NULL; |
| jobjectArray array; |
| jclass java_lang_String = NULL; |
| std::vector<std::string> stringVector; |
| |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| |
| WeaveLogProgress(DeviceManager, "getStringArray() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->GetStringArray(pPathStr, stringVector); |
| SuccessOrExit(err); |
| |
| java_lang_String = env->FindClass("java/lang/String"); |
| VerifyOrExit(java_lang_String != NULL, err = WDM_JNI_ERROR_TYPE_NOT_FOUND); |
| |
| array = env->NewObjectArray(stringVector.size(), java_lang_String, NULL); |
| |
| for (size_t i = 0; i < stringVector.size(); ++i) |
| { |
| jstring obj = env->NewStringUTF(stringVector[i].c_str()); |
| env->SetObjectArrayElement(array, i, obj); |
| env->DeleteLocalRef(obj); |
| obj = NULL; |
| } |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| return array; |
| } |
| |
| jboolean Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_isNull(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr, jstring path) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| bool isNull = false; |
| const char *pPathStr = NULL; |
| |
| WeaveLogProgress(DeviceManager, "isNull() called"); |
| |
| pPathStr = env->GetStringUTFChars(path, 0); |
| VerifyOrExit(pPathStr != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| |
| err = pDataSink->IsNull(pPathStr, isNull); |
| |
| exit: |
| if (pPathStr != NULL) |
| { |
| env->ReleaseStringUTFChars(path, pPathStr); |
| } |
| |
| if (err != WEAVE_NO_ERROR && err != WDM_JNI_ERROR_EXCEPTION_THROWN) |
| { |
| ThrowError(env, err); |
| } |
| |
| return isNull ? JNI_TRUE : JNI_FALSE; |
| } |
| |
| NL_DLL_EXPORT jlong Java_nl_Weave_DataManagement_GenericTraitUpdatableDataSinkImpl_getVersion(JNIEnv *env, jobject self, jlong genericTraitUpdatableDataSinkPtr) |
| { |
| GenericTraitUpdatableDataSink *pDataSink = (GenericTraitUpdatableDataSink *)genericTraitUpdatableDataSinkPtr; |
| uint64_t version = 0; |
| |
| WeaveLogProgress(DeviceManager, "getVersion() called"); |
| |
| version = pDataSink->GetVersion(); |
| |
| return (jlong)version; |
| } |
| |
| namespace nl { |
| namespace Weave { |
| namespace Profiles { |
| namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) { |
| |
| SubscriptionEngine * SubscriptionEngine::GetInstance() |
| { |
| static nl::Weave::Profiles::DataManagement::SubscriptionEngine sWdmSubscriptionEngine; |
| return &sWdmSubscriptionEngine; |
| } |
| |
| namespace Platform { |
| void CriticalSectionEnter() |
| { |
| return; |
| } |
| |
| void CriticalSectionExit() |
| { |
| return; |
| } |
| |
| } // Platform |
| |
| } // WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) |
| } // Profiles |
| } // Weave |
| } // nl |
| #endif // WEAVE_CONFIG_DATA_MANAGEMENT_CLIENT_EXPERIMENTAL |
| |
| namespace nl { |
| namespace Weave { |
| namespace Platform { |
| namespace PersistedStorage { |
| |
| /* |
| * Dummy implementations of PersistedStorage platform methods. These aren't |
| * used in the context of the Java DeviceManager, but are required to satisfy |
| * the linker. |
| */ |
| |
| WEAVE_ERROR Read(const char *aKey, uint32_t &aValue) |
| { |
| return WEAVE_NO_ERROR; |
| } |
| |
| WEAVE_ERROR Write(const char *aKey, uint32_t aValue) |
| { |
| return WEAVE_NO_ERROR; |
| } |
| |
| } // PersistentStorage |
| } // Platform |
| } // Weave |
| } // nl |