src/platform/ble/bluez/WoBluez.cpp - third_party/openweave-core - Git at Google

 /*
  *
  *    Copyright (c) 2017-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
  *      This file defines WoBluez peripheral interface implementation that hands the wrapper talking with BleLayer via the
  *      corresponding platform interface function when the application passively receives an incoming BLE connection.
  *
  */

 #include "WoBluez.h"
 #include "BluezHelperCode.h"

 #include <InetLayer/InetLayer.h>
 #include <Weave/Core/WeaveCore.h>
 #include <Weave/Profiles/echo/WeaveEcho.h>
 #include <Weave/Support/CodeUtils.h>
 #include <Weave/Support/ErrorStr.h>

 #if CONFIG_BLE_PLATFORM_BLUEZ

 namespace nl {
 namespace Ble {
 namespace Platform {
 namespace BlueZ {

 // TODO: use single /ble definition of this
 const WeaveBleUUID WEAVE_BLE_CHAR_1_ID = { { // 18EE2EF5-263D-4559-959F-4F9C429F9D11
                                              0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F,
                                              0x9D, 0x11 } };

 const WeaveBleUUID WEAVE_BLE_CHAR_2_ID = { { // 18EE2EF5-263D-4559-959F-4F9C429F9D12
                                              0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F,
                                              0x9D, 0x12 } };

 void WoBLEz_NewConnection(void * data)
 {
     WeaveLogProgress(Ble, "WoBLEz_NewConnection: %p", data);
 }

 void WoBLEz_WriteReceived(void * data, const uint8_t * value, size_t len)
 {
     // Peripheral behaviour
     WEAVE_ERROR err                          = WEAVE_NO_ERROR;
     nl::Weave::System::PacketBuffer * msgBuf = NULL;
     nl::Weave::System::Error syserr          = WEAVE_SYSTEM_NO_ERROR;
     InEventParam * params                    = NULL;

     msgBuf = nl::Weave::System::PacketBuffer::New();

     VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);
     VerifyOrExit(msgBuf->AvailableDataLength() >= len, err = WEAVE_ERROR_BUFFER_TOO_SMALL);

     syserr = gBluezBlePlatformDelegate->NewEventParams(&params);
     SuccessOrExit(syserr);

     memcpy(msgBuf->Start(), value, len);
     msgBuf->SetDataLength(len);

     params->EventType            = InEventParam::EventTypeEnum::kEvent_WriteReceived;
     params->ConnectionObject     = data;
     params->WriteReceived.SvcId  = &(nl::Ble::WEAVE_BLE_SVC_ID);
     params->WriteReceived.CharId = &(WEAVE_BLE_CHAR_1_ID);
     params->WriteReceived.MsgBuf = msgBuf;

     syserr = gBluezBlePlatformDelegate->SendToWeaveThread(params);
     SuccessOrExit(syserr);

     if (gBluezBleApplicationDelegate != NULL)
     {
         gBluezBleApplicationDelegate->NotifyBleActivity(kWoBlePktRx);
     }
     params = NULL;
     msgBuf = NULL;

 exit:
     if (syserr != WEAVE_SYSTEM_NO_ERROR)
     {
         WeaveLogError(Ble, "WoBLEz_WriteReceived syserr: %d", syserr);
     }

     if (params != NULL)
     {
         gBluezBlePlatformDelegate->ReleaseEventParams(params);
     }

     if (err != WEAVE_NO_ERROR)
     {
         WeaveLogError(Ble, "WoBLEz_WriteReceived failed: %d", err);
     }

     if (NULL != msgBuf)
     {
         nl::Weave::System::PacketBuffer::Free(msgBuf);
     }
 }

 int WoBLEz_SendIndication(void * aClosure)
 {
     BluezServerEndpoint * endpoint            = gBluezServerEndpoint;
     nl::Weave::System::PacketBuffer * msgBuf  = static_cast<nl::Weave::System::PacketBuffer *>(aClosure);
     uint8_t * buffer                          = msgBuf->Start();
     size_t len                                = msgBuf->DataLength();
 #if BLE_CONFIG_BLUEZ_MTU_FEATURE
     struct iovec ioData;
 #endif // BLE_CONFIG_BLUEZ_MTU_FEATURE

     g_free(endpoint->weaveC2->value);
     endpoint->weaveC2->valueLen = len;
     endpoint->weaveC2->value    = static_cast<uint8_t *>(g_memdup(buffer, len));

 #if BLE_CONFIG_BLUEZ_MTU_FEATURE
     if (endpoint->weaveC2->indicatePipeIO)
     {
         ioData.iov_base = static_cast<void *>(endpoint->weaveC2->value);
         ioData.iov_len  = endpoint->weaveC2->valueLen;

         if (io_send(endpoint->weaveC2->indicatePipeIO, &ioData, 1) < 0)
         {
             WeaveLogError(Ble, "weave C2 fails to write into pipe");
         }
     }
 #else  // BLE_CONFIG_BLUEZ_MTU_FEATURE,
     g_dbus_emit_property_changed(endpoint->weaveC2->dbusConn, endpoint->weaveC2->path, CHARACTERISTIC_INTERFACE, "Value");
 #endif // BLE_CONFIG_BLUEZ_MTU_FEATURE

     if (gBluezBleApplicationDelegate != NULL)
     {
         gBluezBleApplicationDelegate->NotifyBleActivity(kWoBlePktTx);
     }
     nl::Weave::System::PacketBuffer::Free(msgBuf);

     return G_SOURCE_REMOVE;
 }

 bool WoBLEz_ScheduleSendIndication(void * data, nl::Weave::System::PacketBuffer * msgBuf)
 {
     const char * msg               = NULL;
     bool success                   = false;
     BluezServerEndpoint * endpoint = static_cast<BluezServerEndpoint *>(data);

     VerifyOrExit(endpoint != NULL, msg = "endpoint is NULL in WoBLEz_SendIndication");
     VerifyOrExit(endpoint == gBluezServerEndpoint, msg = "Unexpected endpoint in WoBLEz_SendIndication");
     VerifyOrExit(endpoint->weaveC2 != NULL, msg = "weaveC2 is NULL in WoBLEz_SendIndication");

     success = RunOnBluezIOThread(WoBLEz_SendIndication, msgBuf);

 exit:

     if (NULL != msg)
     {
         WeaveLogError(Ble, msg);
     }

     if (!success && msgBuf != NULL)
     {
         nl::Weave::System::PacketBuffer::Free(msgBuf);
     }

     return success;
 }

 void WoBLEz_ConnectionClosed(void * data)
 {
     InEventParam * params        = NULL;
     nl::Weave::System::Error err = WEAVE_SYSTEM_NO_ERROR;

     if (data == NULL)
     {
         WeaveLogProgress(Ble, "WoBLEz connection has closed");
         ExitNow();
     }
     WeaveLogProgress(Ble, "WoBLEz_ConnectionClosed: %p", data);

     err = gBluezBlePlatformDelegate->NewEventParams(&params);
     SuccessOrExit(err);

     params->EventType            = InEventParam::EventTypeEnum::kEvent_ConnectionError;
     params->ConnectionObject     = data;
     params->ConnectionError.mErr = BLE_ERROR_REMOTE_DEVICE_DISCONNECTED;

     err = gBluezBlePlatformDelegate->SendToWeaveThread(params);
     SuccessOrExit(err);

     params = NULL;

 exit:
     if (err != WEAVE_SYSTEM_NO_ERROR)
     {
         WeaveLogError(Ble, "WoBLEz_ConnectionClosed err: %d", err);
     }

     if (params != NULL)
     {
         gBluezBlePlatformDelegate->ReleaseEventParams(params);
     }
 }

 void WoBLEz_SubscriptionChange(void * data)
 {
     InEventParam * params          = NULL;
     nl::Weave::System::Error err   = WEAVE_SYSTEM_NO_ERROR;
     BluezServerEndpoint * endpoint = static_cast<BluezServerEndpoint *>(data);
     const char * msg               = NULL;

     VerifyOrExit(endpoint != NULL, msg = "endpoint is NULL in WoBLEz_SubscriptionChange");
     VerifyOrExit(endpoint == gBluezServerEndpoint, msg = "Unexpected endpoint in WoBLEz_SubscriptionChange");
     VerifyOrExit(endpoint->weaveC2 != NULL, msg = "weaveC2 is NULL in WoBLEz_SubscriptionChange");

     err = gBluezBlePlatformDelegate->NewEventParams(&params);
     SuccessOrExit(err);

     params->EventType = endpoint->weaveC2->isNotifying ? InEventParam::EventTypeEnum::kEvent_SubscribeReceived
                                                        : InEventParam::EventTypeEnum::kEvent_UnsubscribeReceived;
     params->ConnectionObject          = data;
     params->SubscriptionChange.SvcId  = &(nl::Ble::WEAVE_BLE_SVC_ID);
     params->SubscriptionChange.CharId = &(WEAVE_BLE_CHAR_2_ID);

     err = gBluezBlePlatformDelegate->SendToWeaveThread(params);
     SuccessOrExit(err);

     params = NULL;

 exit:

     if (err != WEAVE_SYSTEM_NO_ERROR)
     {
         WeaveLogError(Ble, "WoBLEz_ConnectionClosed err: %d", err);
     }

     if (params != NULL)
     {
         gBluezBlePlatformDelegate->ReleaseEventParams(params);
     }

     if (NULL != msg)
     {
         WeaveLogError(Ble, msg);
     }
 }

 void WoBLEz_IndicationConfirmation(void * data)
 {
     InEventParam * params        = NULL;
     nl::Weave::System::Error err = WEAVE_SYSTEM_NO_ERROR;

     err = gBluezBlePlatformDelegate->NewEventParams(&params);
     SuccessOrExit(err);

     params->EventType                     = InEventParam::EventTypeEnum::kEvent_IndicationConfirmation;
     params->ConnectionObject              = data;
     params->IndicationConfirmation.SvcId  = &(nl::Ble::WEAVE_BLE_SVC_ID);
     params->IndicationConfirmation.CharId = &(WEAVE_BLE_CHAR_2_ID);

     err = gBluezBlePlatformDelegate->SendToWeaveThread(params);
     SuccessOrExit(err);

     params = NULL;

 exit:
     if (err != WEAVE_SYSTEM_NO_ERROR)
     {
         WeaveLogError(Ble, "WoBLEz_IndicationConfirmation err: %d", err);
     }

     if (params != NULL)
     {
         gBluezBlePlatformDelegate->ReleaseEventParams(params);
     }
 }

 } // namespace BlueZ
 } /* namespace Platform */
 } /* namespace Ble */
 } /* namespace nl */

 #endif /* CONFIG_BLE_PLATFORM_BLUEZ */
	/*
	*
	* Copyright (c) 2017-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
	* This file defines WoBluez peripheral interface implementation that hands the wrapper talking with BleLayer via the
	* corresponding platform interface function when the application passively receives an incoming BLE connection.
	*
	*/

	#include "WoBluez.h"
	#include "BluezHelperCode.h"

	#include <InetLayer/InetLayer.h>
	#include <Weave/Core/WeaveCore.h>
	#include <Weave/Profiles/echo/WeaveEcho.h>
	#include <Weave/Support/CodeUtils.h>
	#include <Weave/Support/ErrorStr.h>

	#if CONFIG_BLE_PLATFORM_BLUEZ

	namespace nl {
	namespace Ble {
	namespace Platform {
	namespace BlueZ {

	// TODO: use single /ble definition of this
	const WeaveBleUUID WEAVE_BLE_CHAR_1_ID = { { // 18EE2EF5-263D-4559-959F-4F9C429F9D11
	0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F,
	0x9D, 0x11 } };

	const WeaveBleUUID WEAVE_BLE_CHAR_2_ID = { { // 18EE2EF5-263D-4559-959F-4F9C429F9D12
	0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F,
	0x9D, 0x12 } };

	void WoBLEz_NewConnection(void * data)
	{
	WeaveLogProgress(Ble, "WoBLEz_NewConnection: %p", data);
	}

	void WoBLEz_WriteReceived(void * data, const uint8_t * value, size_t len)
	{
	// Peripheral behaviour
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	nl::Weave::System::PacketBuffer * msgBuf = NULL;
	nl::Weave::System::Error syserr = WEAVE_SYSTEM_NO_ERROR;
	InEventParam * params = NULL;

	msgBuf = nl::Weave::System::PacketBuffer::New();

	VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);
	VerifyOrExit(msgBuf->AvailableDataLength() >= len, err = WEAVE_ERROR_BUFFER_TOO_SMALL);

	syserr = gBluezBlePlatformDelegate->NewEventParams(&params);
	SuccessOrExit(syserr);

	memcpy(msgBuf->Start(), value, len);
	msgBuf->SetDataLength(len);

	params->EventType = InEventParam::EventTypeEnum::kEvent_WriteReceived;
	params->ConnectionObject = data;
	params->WriteReceived.SvcId = &(nl::Ble::WEAVE_BLE_SVC_ID);
	params->WriteReceived.CharId = &(WEAVE_BLE_CHAR_1_ID);
	params->WriteReceived.MsgBuf = msgBuf;

	syserr = gBluezBlePlatformDelegate->SendToWeaveThread(params);
	SuccessOrExit(syserr);

	if (gBluezBleApplicationDelegate != NULL)
	{
	gBluezBleApplicationDelegate->NotifyBleActivity(kWoBlePktRx);
	}
	params = NULL;
	msgBuf = NULL;

	exit:
	if (syserr != WEAVE_SYSTEM_NO_ERROR)
	{
	WeaveLogError(Ble, "WoBLEz_WriteReceived syserr: %d", syserr);
	}

	if (params != NULL)
	{
	gBluezBlePlatformDelegate->ReleaseEventParams(params);
	}

	if (err != WEAVE_NO_ERROR)
	{
	WeaveLogError(Ble, "WoBLEz_WriteReceived failed: %d", err);
	}

	if (NULL != msgBuf)
	{
	nl::Weave::System::PacketBuffer::Free(msgBuf);
	}
	}

	int WoBLEz_SendIndication(void * aClosure)
	{
	BluezServerEndpoint * endpoint = gBluezServerEndpoint;
	nl::Weave::System::PacketBuffer * msgBuf = static_cast<nl::Weave::System::PacketBuffer *>(aClosure);
	uint8_t * buffer = msgBuf->Start();
	size_t len = msgBuf->DataLength();
	#if BLE_CONFIG_BLUEZ_MTU_FEATURE
	struct iovec ioData;
	#endif // BLE_CONFIG_BLUEZ_MTU_FEATURE

	g_free(endpoint->weaveC2->value);
	endpoint->weaveC2->valueLen = len;
	endpoint->weaveC2->value = static_cast<uint8_t *>(g_memdup(buffer, len));

	#if BLE_CONFIG_BLUEZ_MTU_FEATURE
	if (endpoint->weaveC2->indicatePipeIO)
	{
	ioData.iov_base = static_cast<void *>(endpoint->weaveC2->value);
	ioData.iov_len = endpoint->weaveC2->valueLen;

	if (io_send(endpoint->weaveC2->indicatePipeIO, &ioData, 1) < 0)
	{
	WeaveLogError(Ble, "weave C2 fails to write into pipe");
	}
	}
	#else // BLE_CONFIG_BLUEZ_MTU_FEATURE,
	g_dbus_emit_property_changed(endpoint->weaveC2->dbusConn, endpoint->weaveC2->path, CHARACTERISTIC_INTERFACE, "Value");
	#endif // BLE_CONFIG_BLUEZ_MTU_FEATURE

	if (gBluezBleApplicationDelegate != NULL)
	{
	gBluezBleApplicationDelegate->NotifyBleActivity(kWoBlePktTx);
	}
	nl::Weave::System::PacketBuffer::Free(msgBuf);

	return G_SOURCE_REMOVE;
	}

	bool WoBLEz_ScheduleSendIndication(void * data, nl::Weave::System::PacketBuffer * msgBuf)
	{
	const char * msg = NULL;
	bool success = false;
	BluezServerEndpoint * endpoint = static_cast<BluezServerEndpoint *>(data);

	VerifyOrExit(endpoint != NULL, msg = "endpoint is NULL in WoBLEz_SendIndication");
	VerifyOrExit(endpoint == gBluezServerEndpoint, msg = "Unexpected endpoint in WoBLEz_SendIndication");
	VerifyOrExit(endpoint->weaveC2 != NULL, msg = "weaveC2 is NULL in WoBLEz_SendIndication");

	success = RunOnBluezIOThread(WoBLEz_SendIndication, msgBuf);

	exit:

	if (NULL != msg)
	{
	WeaveLogError(Ble, msg);
	}

	if (!success && msgBuf != NULL)
	{
	nl::Weave::System::PacketBuffer::Free(msgBuf);
	}

	return success;
	}

	void WoBLEz_ConnectionClosed(void * data)
	{
	InEventParam * params = NULL;
	nl::Weave::System::Error err = WEAVE_SYSTEM_NO_ERROR;

	if (data == NULL)
	{
	WeaveLogProgress(Ble, "WoBLEz connection has closed");
	ExitNow();
	}
	WeaveLogProgress(Ble, "WoBLEz_ConnectionClosed: %p", data);

	err = gBluezBlePlatformDelegate->NewEventParams(&params);
	SuccessOrExit(err);

	params->EventType = InEventParam::EventTypeEnum::kEvent_ConnectionError;
	params->ConnectionObject = data;
	params->ConnectionError.mErr = BLE_ERROR_REMOTE_DEVICE_DISCONNECTED;

	err = gBluezBlePlatformDelegate->SendToWeaveThread(params);
	SuccessOrExit(err);

	params = NULL;

	exit:
	if (err != WEAVE_SYSTEM_NO_ERROR)
	{
	WeaveLogError(Ble, "WoBLEz_ConnectionClosed err: %d", err);
	}

	if (params != NULL)
	{
	gBluezBlePlatformDelegate->ReleaseEventParams(params);
	}
	}

	void WoBLEz_SubscriptionChange(void * data)
	{
	InEventParam * params = NULL;
	nl::Weave::System::Error err = WEAVE_SYSTEM_NO_ERROR;
	BluezServerEndpoint * endpoint = static_cast<BluezServerEndpoint *>(data);
	const char * msg = NULL;

	VerifyOrExit(endpoint != NULL, msg = "endpoint is NULL in WoBLEz_SubscriptionChange");
	VerifyOrExit(endpoint == gBluezServerEndpoint, msg = "Unexpected endpoint in WoBLEz_SubscriptionChange");
	VerifyOrExit(endpoint->weaveC2 != NULL, msg = "weaveC2 is NULL in WoBLEz_SubscriptionChange");

	err = gBluezBlePlatformDelegate->NewEventParams(&params);
	SuccessOrExit(err);

	params->EventType = endpoint->weaveC2->isNotifying ? InEventParam::EventTypeEnum::kEvent_SubscribeReceived
	: InEventParam::EventTypeEnum::kEvent_UnsubscribeReceived;
	params->ConnectionObject = data;
	params->SubscriptionChange.SvcId = &(nl::Ble::WEAVE_BLE_SVC_ID);
	params->SubscriptionChange.CharId = &(WEAVE_BLE_CHAR_2_ID);

	err = gBluezBlePlatformDelegate->SendToWeaveThread(params);
	SuccessOrExit(err);

	params = NULL;

	exit:

	if (err != WEAVE_SYSTEM_NO_ERROR)
	{
	WeaveLogError(Ble, "WoBLEz_ConnectionClosed err: %d", err);
	}

	if (params != NULL)
	{
	gBluezBlePlatformDelegate->ReleaseEventParams(params);
	}

	if (NULL != msg)
	{
	WeaveLogError(Ble, msg);
	}
	}

	void WoBLEz_IndicationConfirmation(void * data)
	{
	InEventParam * params = NULL;
	nl::Weave::System::Error err = WEAVE_SYSTEM_NO_ERROR;

	err = gBluezBlePlatformDelegate->NewEventParams(&params);
	SuccessOrExit(err);

	params->EventType = InEventParam::EventTypeEnum::kEvent_IndicationConfirmation;
	params->ConnectionObject = data;
	params->IndicationConfirmation.SvcId = &(nl::Ble::WEAVE_BLE_SVC_ID);
	params->IndicationConfirmation.CharId = &(WEAVE_BLE_CHAR_2_ID);

	err = gBluezBlePlatformDelegate->SendToWeaveThread(params);
	SuccessOrExit(err);

	params = NULL;

	exit:
	if (err != WEAVE_SYSTEM_NO_ERROR)
	{
	WeaveLogError(Ble, "WoBLEz_IndicationConfirmation err: %d", err);
	}

	if (params != NULL)
	{
	gBluezBlePlatformDelegate->ReleaseEventParams(params);
	}
	}

	} // namespace BlueZ
	} /* namespace Platform */
	} /* namespace Ble */
	} /* namespace nl */

	#endif /* CONFIG_BLE_PLATFORM_BLUEZ */