plugins/src/plugininterface.c

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 /**
  22  * @file
  23  *
  24  * This file contains APIs for Plugin Interface module to be implemented.
  25  */
  26
  27 #include "plugininterface.h"
  28 #include "plugintranslatortypes.h"
  29 #include "pluginlist.h"
  30 #include "zigbee_wrapper.h"
  31 #include "oic_string.h"
  32 #include "oic_malloc.h"
  33 #include "ocstack.h"
  34 #include "ocpayload.h"
  35 #include "logger.h"
  36
  37 #include <string.h>
  38 #include <stdlib.h>
  39
  40 #define TAG PCF("pluginInterface")
  41
  42 /**
  43  * Entity handler callback that fills the resPayload of the entityHandlerRequest.
  44  */
  45 OCEntityHandlerResult PluginInterfaceEntityHandler(OCEntityHandlerFlag flag,
  46                                                    OCEntityHandlerRequest * entityHandlerRequest,
  47                                                    void* callbackParam)
  48 {
  49     if (!entityHandlerRequest)
  50     {
  51         OC_LOG (ERROR, TAG, "Invalid request pointer");
  52         return OC_EH_ERROR;
  53     }
  54
  55     OCEntityHandlerResult ehResult = OC_EH_ERROR;
  56     OCStackResult result = OC_STACK_ERROR;
  57     PIPluginBase * plugin = (PIPluginBase *) callbackParam;
  58
  59     OCEntityHandlerResponse * response =
  60                         (OCEntityHandlerResponse *) OICCalloc(1, sizeof(*response));
  61
  62     if (!response)
  63     {
  64         return OC_EH_ERROR;
  65     }
  66
  67     OCRepPayload* payload = (OCRepPayload *) entityHandlerRequest->payload;
  68
  69     if (flag & OC_REQUEST_FLAG)
  70     {
  71         if (plugin->processEHRequest)
  72         {
  73             ehResult = plugin->processEHRequest(plugin, entityHandlerRequest, &payload);
  74         }
  75     }
  76
  77     // If the result isn't an error or forbidden, send response
  78     if (!((ehResult == OC_EH_ERROR) || (ehResult == OC_EH_FORBIDDEN)))
  79     {
  80         // Format the response.  Note this requires some info about the request
  81         response->requestHandle = entityHandlerRequest->requestHandle;
  82         response->resourceHandle = entityHandlerRequest->resource;
  83         response->ehResult = ehResult;
  84         response->payload = (OCPayload*) payload;
  85         // Indicate that response is NOT in a persistent buffer
  86         response->persistentBufferFlag = 0;
  87
  88         result = OCDoResponse(response);
  89         if (result != OC_STACK_OK)
  90         {
  91             OC_LOG_V(ERROR, TAG, "Error sending response %u", result);
  92             ehResult = OC_EH_ERROR;
  93         }
  94     }
  95     else
  96     {
  97         OC_LOG_V(ERROR, TAG, "Error handling request %u", ehResult);
  98     }
  99
 100     OCPayloadDestroy(response->payload);
 101     OICFree(response);
 102     return ehResult;
 103 }
 104
 105 void piNewResourceCB(PIPluginBase * p_plugin, PIResourceBase * r_newResource)
 106 {
 107     if (!p_plugin || !r_newResource)
 108     {
 109         return;
 110     }
 111
 112     r_newResource->piResource.resourceProperties = OC_DISCOVERABLE | OC_OBSERVABLE;
 113     OCStackResult result = OCCreateResource(&r_newResource->piResource.resourceHandle,
 114                                             r_newResource->piResource.resourceTypeName,
 115                                             r_newResource->piResource.resourceInterfaceName,
 116                                             r_newResource->piResource.uri,
 117                                             PluginInterfaceEntityHandler,
 118                                             (void *) p_plugin,
 119                                             r_newResource->piResource.resourceProperties);
 120     if (result != OC_STACK_OK)
 121     {
 122         OICFree (r_newResource->piResource.uri);
 123         OICFree (r_newResource);
 124         return;
 125     }
 126     OC_LOG_V(INFO, TAG, "Created resource of type: %s\n",
 127         r_newResource->piResource.resourceTypeName);
 128
 129     result = AddResourceToPlugin(p_plugin, r_newResource);
 130 }
 131
 132 void piObserveNotificationUpdate(PIPluginBase * plugin, const char * uri)
 133 {
 134     if(!plugin || !uri)
 135     {
 136         return;
 137     }
 138     PIResource * piResource = NULL;
 139
 140     OCStackResult result = GetResourceFromURI(plugin, &piResource, uri);
 141     if(result != OC_STACK_OK)
 142     {
 143         OC_LOG(ERROR, TAG, "Failed to find a matching URI based on observe notification update.");
 144         return;
 145     }
 146
 147     result = OCNotifyAllObservers(piResource->resourceHandle, OC_LOW_QOS);
 148     if(result != OC_STACK_OK && result != OC_STACK_NO_OBSERVERS)
 149     {
 150         OC_LOG_V(ERROR, TAG, "Failed to notify observers of update. Result: %d", result);
 151     }
 152 }
 153
 154 OCStackResult PIStartPlugin(const char * comPort, PIPluginType pluginType, PIPlugin ** plugin)
 155 {
 156     if (!plugin || !comPort || strlen(comPort) == 0)
 157     {
 158         return OC_STACK_INVALID_PARAM;
 159     }
 160     OCStackResult result = OC_STACK_ERROR;
 161     if (pluginType == PLUGIN_ZIGBEE)
 162     {
 163         result = ZigbeeInit(comPort,
 164                             (PIPlugin_Zigbee **) plugin,
 165                             piNewResourceCB,
 166                             piObserveNotificationUpdate);
 167         if (result != OC_STACK_OK)
 168         {
 169             return result;
 170         }
 171         if (!*plugin)
 172         {
 173             return OC_STACK_ERROR;
 174         }
 175         result = AddPlugin((PIPluginBase *) *plugin);
 176         if (result == OC_STACK_OK)
 177         {
 178             result = ZigbeeDiscover((PIPlugin_Zigbee *) plugin);
 179         }
 180     }
 181     return result;
 182 }
 183
 184 OCStackResult PIStopPlugin(PIPlugin * plugin)
 185 {
 186     if (!plugin)
 187     {
 188         return OC_STACK_INVALID_PARAM;
 189     }
 190
 191     return DeletePlugin((PIPluginBase *) plugin);
 192 }
 193
 194 OCStackResult PIStopAll()
 195 {
 196     return DeletePluginList();
 197 }
 198
 199 OCStackResult PIProcess(PIPlugin * p_plugin)
 200 {
 201     PIPluginBase * plugin = (PIPluginBase *) p_plugin;
 202     if (!plugin)
 203     {
 204         return OC_STACK_INVALID_PARAM;
 205     }
 206     OCStackResult result = OC_STACK_ERROR;
 207     if (plugin->type == PLUGIN_ZIGBEE)
 208     {
 209         result = ZigbeeProcess((PIPlugin_Zigbee *)plugin);
 210     }
 211     return result;
 212 }
 213