From d38415634a6e0d2175e888618a6ebc52dfcb861e Mon Sep 17 00:00:00 2001 From: Robert Quattlebaum Date: Mon, 17 Jul 2017 19:32:56 -0700 Subject: lowpan: Introduce C++ versions of various java classes This change introduces C++ versions of the following java classes: * android.net.lowpan.LowpanIdentity * android.net.lowpan.LowpanCredential * android.net.lowpan.LowpanProvision * android.net.lowpan.LowpanBeaconInfo * android.net.lowpan.LowpanChannelInfo Bug: b/63707448 b/63708348 Test: Confirmed with unit tests from change id I41d590b1e77dc41873c4b9e9bf1b7f1bf859f74e Change-Id: I3dc7b9ca3b33b2ee5f92c8f76c28710997fb931d --- libandroid_net_lowpan/Android.mk | 33 ++++ libandroid_net_lowpan/LowpanBeaconInfo.cpp | 218 +++++++++++++++++++++ libandroid_net_lowpan/LowpanChannelInfo.cpp | 114 +++++++++++ libandroid_net_lowpan/LowpanCredential.cpp | 149 ++++++++++++++ libandroid_net_lowpan/LowpanIdentity.cpp | 189 ++++++++++++++++++ libandroid_net_lowpan/LowpanProvision.cpp | 121 ++++++++++++ .../include/android/net/lowpan/LowpanBeaconInfo.h | 101 ++++++++++ .../include/android/net/lowpan/LowpanChannelInfo.h | 64 ++++++ .../include/android/net/lowpan/LowpanCredential.h | 72 +++++++ .../include/android/net/lowpan/LowpanIdentity.h | 90 +++++++++ .../include/android/net/lowpan/LowpanProvision.h | 69 +++++++ 11 files changed, 1220 insertions(+) create mode 100644 libandroid_net_lowpan/Android.mk create mode 100644 libandroid_net_lowpan/LowpanBeaconInfo.cpp create mode 100644 libandroid_net_lowpan/LowpanChannelInfo.cpp create mode 100644 libandroid_net_lowpan/LowpanCredential.cpp create mode 100644 libandroid_net_lowpan/LowpanIdentity.cpp create mode 100644 libandroid_net_lowpan/LowpanProvision.cpp create mode 100644 libandroid_net_lowpan/include/android/net/lowpan/LowpanBeaconInfo.h create mode 100644 libandroid_net_lowpan/include/android/net/lowpan/LowpanChannelInfo.h create mode 100644 libandroid_net_lowpan/include/android/net/lowpan/LowpanCredential.h create mode 100644 libandroid_net_lowpan/include/android/net/lowpan/LowpanIdentity.h create mode 100644 libandroid_net_lowpan/include/android/net/lowpan/LowpanProvision.h (limited to 'libandroid_net_lowpan') diff --git a/libandroid_net_lowpan/Android.mk b/libandroid_net_lowpan/Android.mk new file mode 100644 index 0000000..730d97d --- /dev/null +++ b/libandroid_net_lowpan/Android.mk @@ -0,0 +1,33 @@ +# +# Copyright (C) 2017 The Android Open Source Project +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_MODULE := libandroid_net_lowpan +LOCAL_MODULE_TAGS := optional +LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include +LOCAL_C_INCLUDES := $(LOCAL_PATH)/include +LOCAL_SHARED_LIBRARIES += libbase +LOCAL_SHARED_LIBRARIES += libbinder +LOCAL_SHARED_LIBRARIES += libutils +LOCAL_SHARED_LIBRARIES += liblog +LOCAL_AIDL_INCLUDES += frameworks/native/aidl/binder +LOCAL_AIDL_INCLUDES += frameworks/base/lowpan/java +LOCAL_AIDL_INCLUDES += frameworks/base/core/java +LOCAL_SRC_FILES += $(call all-Iaidl-files-under, ../../../../base/lowpan/java/android/net/lowpan) +LOCAL_SRC_FILES += $(call all-cpp-files-under) +include $(BUILD_SHARED_LIBRARY) diff --git a/libandroid_net_lowpan/LowpanBeaconInfo.cpp b/libandroid_net_lowpan/LowpanBeaconInfo.cpp new file mode 100644 index 0000000..95746df --- /dev/null +++ b/libandroid_net_lowpan/LowpanBeaconInfo.cpp @@ -0,0 +1,218 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#define LOG_TAG "LowpanBeaconInfo" + +#include + +#include +#include +#include + +using android::BAD_TYPE; +using android::BAD_VALUE; +using android::NO_ERROR; +using android::Parcel; +using android::status_t; +using android::UNEXPECTED_NULL; +using android::net::lowpan::LowpanBeaconInfo; +using namespace ::android::binder; + +namespace android { + +namespace net { + +namespace lowpan { + +#define RETURN_IF_FAILED(calledOnce) \ + { \ + status_t returnStatus = calledOnce; \ + if (returnStatus) { \ + ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \ + return returnStatus; \ + } \ + } + +LowpanBeaconInfo::Builder::Builder() { +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setName(const std::string& value) { + mIdentityBuilder.setName(value); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setType(const std::string& value) { + mIdentityBuilder.setType(value); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setType(const ::android::String16& value) { + mIdentityBuilder.setType(value); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setXpanid(const std::vector& value) { + mIdentityBuilder.setXpanid(value); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setXpanid(const uint8_t* valuePtr, int32_t valueLen) { + mIdentityBuilder.setXpanid(valuePtr, valueLen); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setPanid(int32_t value) { + mIdentityBuilder.setPanid(value); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setChannel(int32_t value) { + mIdentityBuilder.setChannel(value); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setLowpanIdentity(const LowpanIdentity& value) { + mIdentityBuilder.setLowpanIdentity(value); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setRssi(int32_t value) { + mRssi = value; + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setLqi(int32_t value) { + mLqi = value; + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setBeaconAddress(const std::vector& value) { + mBeaconAddress = value; + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setBeaconAddress(const uint8_t* valuePtr, int32_t valueLen) { + mBeaconAddress.clear(); + mBeaconAddress.insert(mBeaconAddress.end(), valuePtr, valuePtr + valueLen); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::setFlag(int32_t value) { + mFlags.insert(value); + return *this; +} + +LowpanBeaconInfo::Builder& LowpanBeaconInfo::Builder::clearFlag(int32_t value) { + mFlags.erase(value); + return *this; +} + +LowpanBeaconInfo LowpanBeaconInfo::Builder::build(void) const { + return LowpanBeaconInfo(*this); +} + +LowpanBeaconInfo::LowpanBeaconInfo(const LowpanBeaconInfo::Builder& builder) : + mIdentity(builder.mIdentityBuilder.build()), + mRssi(builder.mRssi), + mLqi(builder.mLqi), + mBeaconAddress(builder.mBeaconAddress), + mFlags(builder.mFlags) +{ +} + +status_t LowpanBeaconInfo::writeToParcel(Parcel* parcel) const { + /* + * Keep implementation in sync with writeToParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanBeaconInfo.java. + */ + + RETURN_IF_FAILED(mIdentity.writeToParcel(parcel)); + RETURN_IF_FAILED(parcel->writeInt32(mRssi)); + RETURN_IF_FAILED(parcel->writeInt32(mLqi)); + RETURN_IF_FAILED(parcel->writeByteVector(mBeaconAddress)); + RETURN_IF_FAILED(parcel->writeInt32(mFlags.size())); + + std::set::const_iterator iter; + std::set::const_iterator end = mFlags.end(); + + for (iter = mFlags.begin(); iter != end; ++iter) { + RETURN_IF_FAILED(parcel->writeInt32(*iter)); + } + + return NO_ERROR; +} + +status_t LowpanBeaconInfo::readFromParcel(const Parcel* parcel) { + /* + * Keep implementation in sync with readFromParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanBeaconInfo.java. + */ + + RETURN_IF_FAILED(mIdentity.readFromParcel(parcel)); + RETURN_IF_FAILED(parcel->readInt32(&mRssi)); + RETURN_IF_FAILED(parcel->readInt32(&mLqi)); + RETURN_IF_FAILED(parcel->readByteVector(&mBeaconAddress)); + + int32_t flagCount = 0; + + RETURN_IF_FAILED(parcel->readInt32(&flagCount)); + + if (flagCount < 0) { + ALOGE("Bad flag count"); + return BAD_VALUE; + } + + mFlags.clear(); + + while (flagCount--) { + int32_t flag = 0; + RETURN_IF_FAILED(parcel->readInt32(&flag)); + mFlags.insert(flag); + } + + return NO_ERROR; +} + +bool LowpanBeaconInfo::operator==(const LowpanBeaconInfo& rhs) +{ + if (mIdentity != rhs.mIdentity) { + return false; + } + + if (mRssi != rhs.mRssi) { + return false; + } + + if (mLqi != rhs.mLqi) { + return false; + } + + if (mBeaconAddress != rhs.mBeaconAddress) { + return false; + } + + if (mFlags != rhs.mFlags) { + return false; + } + + return true; +} + +} // namespace lowpan + +} // namespace net + +} // namespace android diff --git a/libandroid_net_lowpan/LowpanChannelInfo.cpp b/libandroid_net_lowpan/LowpanChannelInfo.cpp new file mode 100644 index 0000000..af4e7a2 --- /dev/null +++ b/libandroid_net_lowpan/LowpanChannelInfo.cpp @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#define LOG_TAG "LowpanChannelInfo" + +#include + +#include +#include +#include + +using android::BAD_TYPE; +using android::BAD_VALUE; +using android::NO_ERROR; +using android::Parcel; +using android::status_t; +using android::UNEXPECTED_NULL; +using android::net::lowpan::LowpanChannelInfo; +using namespace ::android::binder; + +namespace android { + +namespace net { + +namespace lowpan { + +#define RETURN_IF_FAILED(calledOnce) \ + { \ + status_t returnStatus = calledOnce; \ + if (returnStatus) { \ + ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \ + return returnStatus; \ + } \ + } + +status_t LowpanChannelInfo::writeToParcel(Parcel* parcel) const { + /* + * Keep implementation in sync with writeToParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanChannelInfo.java. + */ + + RETURN_IF_FAILED(parcel->writeInt32(mIndex)); + RETURN_IF_FAILED(parcel->writeUtf8AsUtf16(mName)); + RETURN_IF_FAILED(parcel->writeFloat(mSpectrumCenterFrequency)); + RETURN_IF_FAILED(parcel->writeFloat(mSpectrumBandwidth)); + RETURN_IF_FAILED(parcel->writeInt32(mMaxTxPower)); + RETURN_IF_FAILED(parcel->writeBool(mIsMaskedByRegulatoryDomain)); + + return NO_ERROR; +} + +status_t LowpanChannelInfo::readFromParcel(const Parcel* parcel) { + /* + * Keep implementation in sync with readFromParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanChannelInfo.java. + */ + + RETURN_IF_FAILED(parcel->readInt32(&mIndex)); + RETURN_IF_FAILED(parcel->readUtf8FromUtf16(&mName)); + RETURN_IF_FAILED(parcel->readFloat(&mSpectrumCenterFrequency)); + RETURN_IF_FAILED(parcel->readFloat(&mSpectrumBandwidth)); + RETURN_IF_FAILED(parcel->readInt32(&mMaxTxPower)); + RETURN_IF_FAILED(parcel->readBool(&mIsMaskedByRegulatoryDomain)); + + return NO_ERROR; +} + +bool LowpanChannelInfo::operator==(const LowpanChannelInfo& rhs) +{ + if (mIndex != rhs.mIndex) { + return false; + } + + if (mName != rhs.mName) { + return false; + } + + if (mSpectrumCenterFrequency != rhs.mSpectrumCenterFrequency) { + return false; + } + + if (mSpectrumBandwidth != rhs.mSpectrumBandwidth) { + return false; + } + + if (mMaxTxPower != rhs.mMaxTxPower) { + return false; + } + + if (mIsMaskedByRegulatoryDomain != rhs.mIsMaskedByRegulatoryDomain) { + return false; + } + + return true; +} + +} // namespace lowpan + +} // namespace net + +} // namespace android diff --git a/libandroid_net_lowpan/LowpanCredential.cpp b/libandroid_net_lowpan/LowpanCredential.cpp new file mode 100644 index 0000000..f0c6109 --- /dev/null +++ b/libandroid_net_lowpan/LowpanCredential.cpp @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#define LOG_TAG "LowpanCredential" + +#include + +#include +#include +#include + +using android::BAD_TYPE; +using android::BAD_VALUE; +using android::NO_ERROR; +using android::Parcel; +using android::status_t; +using android::UNEXPECTED_NULL; +using android::net::lowpan::LowpanCredential; +using namespace ::android::binder; + +namespace android { + +namespace net { + +namespace lowpan { + +#define RETURN_IF_FAILED(calledOnce) \ + { \ + status_t returnStatus = calledOnce; \ + if (returnStatus) { \ + ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \ + return returnStatus; \ + } \ + } + +LowpanCredential::LowpanCredential() : mMasterKeyIndex(UNSPECIFIED_MASTER_KEY_INDEX) { } + +status_t LowpanCredential::initMasterKey(LowpanCredential& out, const uint8_t* masterKeyBytes, int masterKeyLen, int masterKeyIndex) +{ + if (masterKeyLen < 0) { + return BAD_INDEX; + } else if (masterKeyLen > MASTER_KEY_MAX_SIZE) { + return BAD_INDEX; + } else if (masterKeyBytes == NULL) { + return BAD_VALUE; + } + + out.mMasterKey.clear(); + out.mMasterKey.insert(out.mMasterKey.end(), masterKeyBytes, masterKeyBytes + masterKeyLen); + out.mMasterKeyIndex = masterKeyIndex; + + return NO_ERROR; +} + +status_t LowpanCredential::initMasterKey(LowpanCredential& out, const uint8_t* masterKeyBytes, int masterKeyLen) +{ + return LowpanCredential::initMasterKey(out, masterKeyBytes, masterKeyLen, 0); +} + +status_t LowpanCredential::initMasterKey(LowpanCredential& out, const std::vector& masterKey, int masterKeyIndex) +{ + return LowpanCredential::initMasterKey(out, &masterKey.front(), masterKey.size(), masterKeyIndex); +} + +status_t LowpanCredential::initMasterKey(LowpanCredential& out, const std::vector& masterKey) +{ + return LowpanCredential::initMasterKey(out, masterKey, 0); +} + +bool LowpanCredential::isMasterKey() const { + return mMasterKey.size() > 0; +} + +bool LowpanCredential::getMasterKey(std::vector* masterKey) const { + if (isMasterKey()) { + *masterKey = mMasterKey; + return true; + } + return false; +} + +bool LowpanCredential::getMasterKey(const uint8_t** masterKey, int* masterKeyLen) const { + if (isMasterKey()) { + if (masterKey) { + *masterKey = &mMasterKey.front(); + } + if (masterKeyLen) { + *masterKeyLen = mMasterKey.size(); + } + return true; + } + return false; +} + +int LowpanCredential::getMasterKeyIndex() const { + return mMasterKeyIndex; +} + +status_t LowpanCredential::writeToParcel(Parcel* parcel) const { + /* + * Keep implementation in sync with writeToParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanCredential.java. + */ + RETURN_IF_FAILED(parcel->writeByteVector(mMasterKey)); + RETURN_IF_FAILED(parcel->writeInt32(mMasterKeyIndex)); + return NO_ERROR; +} + +status_t LowpanCredential::readFromParcel(const Parcel* parcel) { + /* + * Keep implementation in sync with readFromParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanCredential.java. + */ + RETURN_IF_FAILED(parcel->readByteVector(&mMasterKey)); + RETURN_IF_FAILED(parcel->readInt32(&mMasterKeyIndex)); + return NO_ERROR; +} + +bool LowpanCredential::operator==(const LowpanCredential& rhs) +{ + if (mMasterKey != rhs.mMasterKey) { + return false; + } + + if (mMasterKeyIndex != rhs.mMasterKeyIndex) { + return false; + } + + return true; +} + +} // namespace lowpan + +} // namespace net + +} // namespace android diff --git a/libandroid_net_lowpan/LowpanIdentity.cpp b/libandroid_net_lowpan/LowpanIdentity.cpp new file mode 100644 index 0000000..0e64c20 --- /dev/null +++ b/libandroid_net_lowpan/LowpanIdentity.cpp @@ -0,0 +1,189 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#define LOG_TAG "LowpanIdentity" + +#include + +#include +#include +#include + +using android::BAD_TYPE; +using android::BAD_VALUE; +using android::NO_ERROR; +using android::Parcel; +using android::status_t; +using android::UNEXPECTED_NULL; +using android::net::lowpan::LowpanIdentity; +using namespace ::android::binder; + +namespace android { + +namespace net { + +namespace lowpan { + +#define RETURN_IF_FAILED(calledOnce) \ + { \ + status_t returnStatus = calledOnce; \ + if (returnStatus) { \ + ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \ + return returnStatus; \ + } \ + } + +bool LowpanIdentity::getName(std::string* value) const { + if (value != NULL) { + *value = mName; + } + return true; +} +bool LowpanIdentity::getType(std::string* value) const { + if (value != NULL) { + *value = mType; + } + return true; +} +bool LowpanIdentity::getXpanid(std::vector* value) const { + if (value != NULL) { + *value = mXpanid; + } + return true; +} +int32_t LowpanIdentity::getPanid(void) const { + return mPanid; +} +int32_t LowpanIdentity::getChannel(void) const { + return mChannel; +} + +LowpanIdentity::Builder::Builder() { +} + +LowpanIdentity::Builder& LowpanIdentity::Builder::setName(const std::string& value) { + mIdentity.mName = value; + return *this; +} + +LowpanIdentity::Builder& LowpanIdentity::Builder::setType(const std::string& value) { + mIdentity.mType = value; + return *this; +} + +LowpanIdentity::Builder& LowpanIdentity::Builder::setType(const ::android::String16& value) { + return setType(String8(value).string()); +} + +LowpanIdentity::Builder& LowpanIdentity::Builder::setXpanid(const std::vector& value) { + mIdentity.mXpanid = value; + return *this; +} + +LowpanIdentity::Builder& LowpanIdentity::Builder::setXpanid(const uint8_t* valuePtr, int32_t valueLen) { + mIdentity.mXpanid.clear(); + mIdentity.mXpanid.insert(mIdentity.mXpanid.end(), valuePtr, valuePtr + valueLen); + return *this; +} + +LowpanIdentity::Builder& LowpanIdentity::Builder::setPanid(int32_t value) { + mIdentity.mPanid = value; + return *this; +} + +LowpanIdentity::Builder& LowpanIdentity::Builder::setChannel(int32_t value) { + mIdentity.mChannel = value; + return *this; +} + +LowpanIdentity::Builder& LowpanIdentity::Builder::setLowpanIdentity(const LowpanIdentity& value) { + mIdentity = value; + return *this; +} + +LowpanIdentity LowpanIdentity::Builder::build(void) const { + return mIdentity; +} + +LowpanIdentity::LowpanIdentity() : mPanid(UNSPECIFIED_PANID), mChannel(UNSPECIFIED_CHANNEL) { +} + +status_t LowpanIdentity::writeToParcel(Parcel* parcel) const { + /* + * Keep implementation in sync with writeToParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanIdentity.java. + */ + + std::vector rawName(mName.begin(), mName.end()); + + RETURN_IF_FAILED(parcel->writeByteVector(rawName)); + RETURN_IF_FAILED(parcel->writeUtf8AsUtf16(mType)); + RETURN_IF_FAILED(parcel->writeByteVector(mXpanid)); + RETURN_IF_FAILED(parcel->writeInt32(mPanid)); + RETURN_IF_FAILED(parcel->writeInt32(mChannel)); + return NO_ERROR; +} + +status_t LowpanIdentity::readFromParcel(const Parcel* parcel) { + /* + * Keep implementation in sync with readFromParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanIdentity.java. + */ + + std::vector rawName; + + RETURN_IF_FAILED(parcel->readByteVector(&rawName)); + + mName = std::string((const char*)&rawName.front(), rawName.size()); + + RETURN_IF_FAILED(parcel->readUtf8FromUtf16(&mType)); + RETURN_IF_FAILED(parcel->readByteVector(&mXpanid)); + RETURN_IF_FAILED(parcel->readInt32(&mPanid)); + RETURN_IF_FAILED(parcel->readInt32(&mChannel)); + return NO_ERROR; +} + +bool LowpanIdentity::operator==(const LowpanIdentity& rhs) +{ + const LowpanIdentity& lhs = *this; + + if (lhs.mName != rhs.mName) { + return false; + } + + if (lhs.mType != rhs.mType) { + return false; + } + + if (lhs.mXpanid != rhs.mXpanid) { + return false; + } + + if (lhs.mPanid != rhs.mPanid) { + return false; + } + + if (lhs.mChannel != rhs.mChannel) { + return false; + } + return true; +} + +} // namespace lowpan + +} // namespace net + +} // namespace android diff --git a/libandroid_net_lowpan/LowpanProvision.cpp b/libandroid_net_lowpan/LowpanProvision.cpp new file mode 100644 index 0000000..315ea54 --- /dev/null +++ b/libandroid_net_lowpan/LowpanProvision.cpp @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#define LOG_TAG "LowpanProvision" + +#include + +#include +#include +#include + +using android::BAD_TYPE; +using android::BAD_VALUE; +using android::NO_ERROR; +using android::Parcel; +using android::status_t; +using android::UNEXPECTED_NULL; +using android::net::lowpan::LowpanProvision; +using namespace ::android::binder; + +namespace android { + +namespace net { + +namespace lowpan { + +#define RETURN_IF_FAILED(calledOnce) \ + { \ + status_t returnStatus = calledOnce; \ + if (returnStatus) { \ + ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \ + return returnStatus; \ + } \ + } +LowpanProvision::LowpanProvision(const LowpanIdentity& identity, const LowpanCredential& credential) + : mIdentity(identity), mCredential(credential), mHasCredential(true) +{ +} + +LowpanProvision::LowpanProvision(const LowpanIdentity& identity) + : mIdentity(identity), mHasCredential(false) +{ +} + +const LowpanIdentity* LowpanProvision::getLowpanIdentity() const { + return &mIdentity; +} + +const LowpanCredential* LowpanProvision::getLowpanCredential() const { + return mHasCredential + ? &mCredential + : NULL; +} + +status_t LowpanProvision::writeToParcel(Parcel* parcel) const { + /* + * Keep implementation in sync with writeToParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanProvision.java. + */ + + RETURN_IF_FAILED(mIdentity.writeToParcel(parcel)); + RETURN_IF_FAILED(parcel->writeBool(mHasCredential)); + + if (mHasCredential) { + RETURN_IF_FAILED(mCredential.writeToParcel(parcel)); + } + + return NO_ERROR; +} + +status_t LowpanProvision::readFromParcel(const Parcel* parcel) { + /* + * Keep implementation in sync with readFromParcel() in + * frameworks/base/lowpan/java/android/net/android/net/lowpan/LowpanProvision.java. + */ + + RETURN_IF_FAILED(mIdentity.readFromParcel(parcel)); + RETURN_IF_FAILED(parcel->readBool(&mHasCredential)); + + if (mHasCredential) { + RETURN_IF_FAILED(mCredential.readFromParcel(parcel)); + } + + return NO_ERROR; +} + +bool LowpanProvision::operator==(const LowpanProvision& rhs) +{ + if (mIdentity != rhs.mIdentity) { + return false; + } + + if (mHasCredential != rhs.mHasCredential) { + return false; + } + + if (mHasCredential && mCredential != rhs.mCredential) { + return false; + } + + return true; +} + +} // namespace lowpan + +} // namespace net + +} // namespace android diff --git a/libandroid_net_lowpan/include/android/net/lowpan/LowpanBeaconInfo.h b/libandroid_net_lowpan/include/android/net/lowpan/LowpanBeaconInfo.h new file mode 100644 index 0000000..9a971ef --- /dev/null +++ b/libandroid_net_lowpan/include/android/net/lowpan/LowpanBeaconInfo.h @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#ifndef ANDROID_LOWPAN_BEACON_INFO_H +#define ANDROID_LOWPAN_BEACON_INFO_H + +#include +#include +#include +#include + +#include "LowpanIdentity.h" + +namespace android { + +namespace net { + +namespace lowpan { + +/* + * C++ implementation of the Java class android.net.lowpan.LowpanBeaconInfo + */ +class LowpanBeaconInfo : public Parcelable { +public: + static const int32_t FLAG_CAN_ASSIST = 1; + + class Builder; + LowpanBeaconInfo() = default; + virtual ~LowpanBeaconInfo() = default; + LowpanBeaconInfo(const LowpanBeaconInfo& x) = default; + + bool operator==(const LowpanBeaconInfo& rhs); + bool operator!=(const LowpanBeaconInfo& rhs) { return !(*this == rhs); } + +public: + // Overrides + status_t writeToParcel(Parcel* parcel) const override; + status_t readFromParcel(const Parcel* parcel) override; + +private: + LowpanBeaconInfo(const Builder& builder); + +private: + // Data + LowpanIdentity mIdentity; + int32_t mRssi; + int32_t mLqi; + std::vector mBeaconAddress; + std::set mFlags; +}; + +class LowpanBeaconInfo::Builder { + friend class LowpanBeaconInfo; +public: + Builder(); + Builder& setName(const std::string& value); + Builder& setType(const std::string& value); + Builder& setType(const ::android::String16& value); + Builder& setXpanid(const std::vector& value); + Builder& setXpanid(const uint8_t* valuePtr, int32_t valueLen); + Builder& setPanid(int32_t value); + Builder& setChannel(int32_t value); + Builder& setLowpanIdentity(const LowpanIdentity& value); + + Builder& setRssi(int32_t value); + Builder& setLqi(int32_t value); + Builder& setBeaconAddress(const std::vector& value); + Builder& setBeaconAddress(const uint8_t* valuePtr, int32_t valueLen); + Builder& setFlag(int32_t value); + Builder& clearFlag(int32_t value); + + LowpanBeaconInfo build(void) const; +private: + LowpanIdentity::Builder mIdentityBuilder; + + int32_t mRssi; + int32_t mLqi; + std::vector mBeaconAddress; + std::set mFlags; +}; + +} // namespace lowpan + +} // namespace net + +} // namespace android + +#endif // ANDROID_LOWPAN_BEACON_INFO_H diff --git a/libandroid_net_lowpan/include/android/net/lowpan/LowpanChannelInfo.h b/libandroid_net_lowpan/include/android/net/lowpan/LowpanChannelInfo.h new file mode 100644 index 0000000..e29820a --- /dev/null +++ b/libandroid_net_lowpan/include/android/net/lowpan/LowpanChannelInfo.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#ifndef ANDROID_LOWPAN_CHANNEL_INFO_H +#define ANDROID_LOWPAN_CHANNEL_INFO_H + +#include +#include +#include +#include + +namespace android { + +namespace net { + +namespace lowpan { + +/* + * C++ implementation of the Java class android.net.lowpan.LowpanChannelInfo + */ +class LowpanChannelInfo : public Parcelable { +public: + LowpanChannelInfo() = default; + virtual ~LowpanChannelInfo() = default; + LowpanChannelInfo(const LowpanChannelInfo& x) = default; + + bool operator==(const LowpanChannelInfo& rhs); + bool operator!=(const LowpanChannelInfo& rhs) { return !(*this == rhs); } + +public: + // Overrides + status_t writeToParcel(Parcel* parcel) const override; + status_t readFromParcel(const Parcel* parcel) override; + +private: + // Data + int32_t mIndex; + std::string mName; + float mSpectrumCenterFrequency; + float mSpectrumBandwidth; + int32_t mMaxTxPower; + bool mIsMaskedByRegulatoryDomain; +}; + +} // namespace lowpan + +} // namespace net + +} // namespace android + +#endif // ANDROID_LOWPAN_CHANNEL_INFO_H diff --git a/libandroid_net_lowpan/include/android/net/lowpan/LowpanCredential.h b/libandroid_net_lowpan/include/android/net/lowpan/LowpanCredential.h new file mode 100644 index 0000000..c8ac90b --- /dev/null +++ b/libandroid_net_lowpan/include/android/net/lowpan/LowpanCredential.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#ifndef ANDROID_LOWPAN_CREDENTIAL_H +#define ANDROID_LOWPAN_CREDENTIAL_H + +#include +#include +#include + +namespace android { + +namespace net { + +namespace lowpan { + +/* + * C++ implementation of the Java class android.net.lowpan.LowpanCredential + */ +class LowpanCredential : public Parcelable { +public: + static const int32_t UNSPECIFIED_MASTER_KEY_INDEX = 0; + static const int MASTER_KEY_MAX_SIZE = 1048576; + + LowpanCredential(); + virtual ~LowpanCredential() = default; + LowpanCredential(const LowpanCredential& x) = default; + + static status_t initMasterKey(LowpanCredential& out, const std::vector& masterKey, int32_t masterKeyIndex); + static status_t initMasterKey(LowpanCredential& out, const std::vector& masterKey); + static status_t initMasterKey(LowpanCredential& out, const uint8_t* masterKeyBytes, int masterKeyLen, int32_t masterKeyIndex); + static status_t initMasterKey(LowpanCredential& out, const uint8_t* masterKeyBytes, int masterKeyLen); + + bool isMasterKey()const; + bool getMasterKey(std::vector* masterKey)const; + bool getMasterKey(const uint8_t** masterKey, int* masterKeyLen)const; + int32_t getMasterKeyIndex()const; + + bool operator==(const LowpanCredential& rhs); + bool operator!=(const LowpanCredential& rhs) { return !(*this == rhs); } + +public: + // Overrides + status_t writeToParcel(Parcel* parcel) const override; + status_t readFromParcel(const Parcel* parcel) override; + +private: + // Data + std::vector mMasterKey; + int32_t mMasterKeyIndex; +}; + +} // namespace lowpan + +} // namespace net + +} // namespace android + +#endif // ANDROID_LOWPAN_CREDENTIAL_H diff --git a/libandroid_net_lowpan/include/android/net/lowpan/LowpanIdentity.h b/libandroid_net_lowpan/include/android/net/lowpan/LowpanIdentity.h new file mode 100644 index 0000000..c82446a --- /dev/null +++ b/libandroid_net_lowpan/include/android/net/lowpan/LowpanIdentity.h @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#ifndef ANDROID_LOWPAN_IDENTITY_H +#define ANDROID_LOWPAN_IDENTITY_H + +#include +#include +#include +#include + +namespace android { + +namespace net { + +namespace lowpan { + +/* + * C++ implementation of the Java class android.net.lowpan.LowpanIdentity + */ +class LowpanIdentity : public Parcelable { +public: + class Builder; + static const int32_t UNSPECIFIED_PANID = 0xFFFFFFFF; + static const int32_t UNSPECIFIED_CHANNEL = -1; + + LowpanIdentity(); + virtual ~LowpanIdentity() = default; + LowpanIdentity(const LowpanIdentity& x) = default; + + bool operator==(const LowpanIdentity& rhs); + bool operator!=(const LowpanIdentity& rhs) { return !(*this == rhs); } + + bool getName(std::string* value) const; + bool getType(std::string* value) const; + bool getXpanid(std::vector* value) const; + int32_t getPanid(void) const; + int32_t getChannel(void) const; + +public: + // Overrides + status_t writeToParcel(Parcel* parcel) const override; + status_t readFromParcel(const Parcel* parcel) override; + +private: + // Data + std::string mName; + std::string mType; + std::vector mXpanid; + int32_t mPanid; + int32_t mChannel; +}; + +class LowpanIdentity::Builder { +public: + Builder(); + Builder& setName(const std::string& value); + Builder& setType(const std::string& value); + Builder& setType(const ::android::String16& value); + Builder& setXpanid(const std::vector& value); + Builder& setXpanid(const uint8_t* valuePtr, int32_t valueLen); + Builder& setPanid(int32_t value); + Builder& setChannel(int32_t value); + Builder& setLowpanIdentity(const LowpanIdentity& value); + + LowpanIdentity build(void) const; +private: + LowpanIdentity mIdentity; +}; + +} // namespace lowpan + +} // namespace net + +} // namespace android + +#endif // ANDROID_LOWPAN_IDENTITY_H diff --git a/libandroid_net_lowpan/include/android/net/lowpan/LowpanProvision.h b/libandroid_net_lowpan/include/android/net/lowpan/LowpanProvision.h new file mode 100644 index 0000000..128994c --- /dev/null +++ b/libandroid_net_lowpan/include/android/net/lowpan/LowpanProvision.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * 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. + */ + +#ifndef ANDROID_LOWPAN_PROVISION_H +#define ANDROID_LOWPAN_PROVISION_H + +#include +#include +#include + +#include "LowpanIdentity.h" +#include "LowpanCredential.h" + +namespace android { + +namespace net { + +namespace lowpan { + +/* + * C++ implementation of the Java class android.net.lowpan.LowpanProvision + */ +class LowpanProvision : public Parcelable { +public: + LowpanProvision() = default; + virtual ~LowpanProvision() = default; + LowpanProvision(const LowpanProvision& x) = default; + + bool operator==(const LowpanProvision& rhs); + bool operator!=(const LowpanProvision& rhs) { return !(*this == rhs); } + + LowpanProvision(const LowpanIdentity& identity, const LowpanCredential& credential); + LowpanProvision(const LowpanIdentity& identity); + + const LowpanIdentity* getLowpanIdentity() const; + const LowpanCredential* getLowpanCredential() const; + +public: + // Overrides + status_t writeToParcel(Parcel* parcel) const override; + status_t readFromParcel(const Parcel* parcel) override; + +private: + // Data + LowpanIdentity mIdentity; + LowpanCredential mCredential; + bool mHasCredential; +}; + +} // namespace lowpan + +} // namespace net + +} // namespace android + +#endif // ANDROID_LOWPAN_PROVISION_H -- cgit v1.2.3