service/notification-manager/SampleApp/android/SampleProviderApp/src/com/example/sample/provider/TemperatureResource.java

   1 package com.example.sample.provider;
   2
   3 import java.util.EnumSet;
   4 import java.util.LinkedList;
   5 import java.util.List;
   6
   7 import org.iotivity.base.EntityHandlerResult;
   8 import org.iotivity.base.ObservationInfo;
   9 import org.iotivity.base.OcException;
  10 import org.iotivity.base.OcPlatform;
  11 import org.iotivity.base.OcRepresentation;
  12 import org.iotivity.base.OcResourceHandle;
  13 import org.iotivity.base.OcResourceRequest;
  14 import org.iotivity.base.OcResourceResponse;
  15 import org.iotivity.base.RequestHandlerFlag;
  16 import org.iotivity.base.RequestType;
  17 import org.iotivity.base.ResourceProperty;
  18
  19 import android.content.Context;
  20 import android.content.Intent;
  21 import android.os.Message;
  22 import android.util.Log;
  23
  24 public class TemperatureResource implements IMessageLogger
  25 {
  26         private Context mContext;
  27         public int mtemp;
  28         public int mhumidity;
  29         private OcRepresentation mTempRep;
  30         private OcResourceHandle mResourceHandle;
  31         private List<Byte> mObservationIds;
  32
  33         private static String TAG = "NMProvider : TemperatureResource";
  34
  35         TemperatureResource(Context context)
  36         {
  37             mContext = context;
  38             mtemp = 0;
  39             mhumidity = 0;
  40             mResourceHandle = null;
  41             mObservationIds = new LinkedList<Byte>();
  42             mTempRep = new OcRepresentation();
  43             mTempRep.setValueInt(StringConstants.TEMPERATURE, mtemp);
  44             mTempRep.setValueInt(StringConstants.HUMIDITY, mhumidity);
  45         }
  46
  47         // accessor methods
  48         protected int getTemp()
  49         {
  50             return mtemp;
  51         }
  52
  53         protected void setTemp(int temp)
  54         {
  55             mtemp = temp;
  56         }
  57
  58         protected int getHumidity()
  59         {
  60             return mhumidity;
  61         }
  62
  63         protected void setHumidity(int humidity)
  64         {
  65             mhumidity = humidity;
  66         }
  67
  68         protected OcResourceHandle getHandle()
  69         {
  70             return mResourceHandle;
  71         }
  72         protected OcResourceHandle destroyResource()
  73         {
  74             if (mResourceHandle != null)
  75             {
  76                 try
  77                 {
  78                     OcPlatform.unregisterResource(mResourceHandle);
  79                 }
  80                 catch (OcException e)
  81                 {
  82                     e.printStackTrace();
  83                 }
  84                 mResourceHandle = null;
  85             }
  86             return null;
  87         }
  88         protected OcResourceHandle createResource()
  89         {
  90
  91             OcPlatform.EntityHandler eh = new OcPlatform.EntityHandler()
  92             {
  93                 @Override
  94                 public EntityHandlerResult handleEntity(
  95                     OcResourceRequest ocResourceRequest)
  96                 {
  97                     // this is where the main logic of simpleserver is handled as
  98                     // different requests (GET, PUT, POST, OBSERVE, DELETE) are
  99                     // handled
 100                     return entityHandler(ocResourceRequest);
 101                 }
 102             };
 103
 104             try
 105             {
 106                 Log.e(TAG, "before registerResource!");
 107                 mResourceHandle = OcPlatform.registerResource(
 108                                       StringConstants.RESOURCE_URI,
 109                                       StringConstants.RESOURCE_TYPENAME,
 110                                       StringConstants.RESOURCE_INTERFACE, eh, EnumSet.of(
 111                                           ResourceProperty.DISCOVERABLE, ResourceProperty.OBSERVABLE));
 112                 Log.e(TAG, "after regiterResource");
 113             }
 114             catch (OcException e)
 115             {
 116                 Log.e(TAG, "go exception");
 117                 logMessage(TAG + "RegisterResource error. " + e.getMessage());
 118                 Log.e(TAG, "RegisterResource error. " + e.getMessage());
 119             }
 120
 121             // logMessage(TAG + "Successfully registered resource");
 122             return mResourceHandle;
 123         }
 124
 125         private void put(OcRepresentation rep)
 126         {
 127             mtemp = rep.getValueInt(StringConstants.TEMPERATURE);
 128             mhumidity = rep.getValueInt(StringConstants.HUMIDITY);
 129             logMessage(TAG + "PUT Request" +"temperature : " + mtemp + "humidity : " + mhumidity);
 130              notifyObserver();
 131             // " Power: " + mPower);
 132              String message = mtemp+":"+mhumidity;
 133              Message msg = Message.obtain();
 134              msg.what = 0;
 135              SampleProvider mainActivityObj = SampleProvider.getSampleProviderObject();
 136              SampleProvider.setmessage(message);
 137              mainActivityObj.getmHandler().sendMessage(msg);
 138
 139         }
 140
 141         protected OcRepresentation get()
 142         {
 143             mTempRep.setValueInt(StringConstants.TEMPERATURE, mtemp);
 144             mTempRep.setValueInt(StringConstants.HUMIDITY, mhumidity);
 145             return mTempRep;
 146         }
 147
 148         private EntityHandlerResult entityHandler(OcResourceRequest request)
 149         {
 150             EntityHandlerResult result = EntityHandlerResult.ERROR;
 151             if (null != request)
 152             {
 153                 RequestType requestType = request.getRequestType();
 154                 EnumSet<RequestHandlerFlag> requestFlag = request
 155                         .getRequestHandlerFlagSet();
 156
 157
 158
 159                 if (requestFlag.contains(RequestHandlerFlag.INIT))
 160                 {
 161                     logMessage(TAG + "Init");
 162                 }
 163
 164                 if (requestFlag.contains(RequestHandlerFlag.REQUEST))
 165                 {
 166                     try
 167                     {
 168                         logMessage(TAG + requestType + "Request");
 169                         OcResourceResponse ocResourceResponse = new OcResourceResponse();
 170                         ocResourceResponse.setRequestHandle(request
 171                                                             .getRequestHandle());
 172                         ocResourceResponse.setResourceHandle(request
 173                                                              .getResourceHandle());
 174
 175                         switch (requestType)
 176                         {
 177                             // handle GET request
 178                             case GET:
 179                                 logMessage("GET");
 180                                 ocResourceResponse
 181                                 .setResponseResult(EntityHandlerResult.OK);
 182                                 ocResourceResponse
 183                                 .setErrorCode(StringConstants.ERROR_CODE);
 184                                 ocResourceResponse.setResourceRepresentation(get());
 185                                 OcPlatform.sendResponse(ocResourceResponse);
 186                                 break;
 187                             // handle PUT request
 188                             case PUT:
 189                                 logMessage(TAG + "PUT");
 190                                 OcRepresentation rep = request
 191                                                        .getResourceRepresentation();
 192                                 put(rep);
 193                                 ocResourceResponse
 194                                 .setErrorCode(StringConstants.ERROR_CODE);
 195                                 ocResourceResponse
 196                                 .setResponseResult(EntityHandlerResult.OK);
 197                                 ocResourceResponse.setResourceRepresentation(get());
 198                                 OcPlatform.sendResponse(ocResourceResponse);
 199                                 break;
 200                             // handle POST request
 201                             case POST:
 202                                 break;
 203                             // handle DELETE request
 204                             case DELETE:
 205                                 logMessage(TAG + "DELETE");
 206                                 OcPlatform.unregisterResource(getHandle());
 207                                 break;
 208
 209                         }
 210
 211                         result = EntityHandlerResult.OK;
 212                     }
 213                     catch (Exception e)
 214                     {
 215                         logMessage(TAG + "Error in Request " + e.getMessage());
 216                         Log.e(TAG, e.getMessage());
 217                     }
 218                 }
 219                 // handle OBSERVER request
 220                 if (requestFlag.contains(RequestHandlerFlag.OBSERVER))
 221                 {
 222                     logMessage(TAG + "OBSERVER");
 223                     ObservationInfo observationInfo = request.getObservationInfo();
 224                     switch (observationInfo.getObserveAction())
 225                     {
 226                         case REGISTER:
 227                             mObservationIds.add(observationInfo
 228                                                 .getOcObservationId());
 229
 230                             break;
 231                         case UNREGISTER:
 232                             mObservationIds.remove(observationInfo
 233                                                    .getOcObservationId());
 234                             break;
 235                     }
 236
 237                     result = EntityHandlerResult.OK;
 238                 }
 239             }
 240             return result;
 241         }
 242
 243         public void logMessage(String msg)
 244         {
 245             logMsg(msg);
 246             Log.i(TAG, msg);
 247         }
 248
 249         public void logMsg(final String text)
 250         {
 251             Intent intent = new Intent("com.example.sample.provider.SampleProvider");
 252             intent.putExtra(StringConstants.MESSAGE, text);
 253             mContext.sendBroadcast(intent);
 254         }
 255
 256         public void notifyObserver()
 257         {
 258             try
 259             {
 260                 // if observationList is not empty, call notifyListOfObservers
 261                 if (mObservationIds.size() > 0)
 262                 {
 263                     OcResourceResponse ocResourceResponse = new OcResourceResponse();
 264                     ocResourceResponse.setErrorCode(StringConstants.ERROR_CODE);
 265                     ocResourceResponse.setResponseResult(EntityHandlerResult.OK);
 266                     OcRepresentation r = get();
 267                     ocResourceResponse.setResourceRepresentation
 268                     (r, OcPlatform.DEFAULT_INTERFACE);
 269                     OcPlatform.notifyListOfObservers(getHandle(), mObservationIds, ocResourceResponse);
 270                 }
 271                 else
 272                 {
 273                     // notify all observers if mObservationList is empty
 274                     OcPlatform.notifyAllObservers(getHandle());
 275                 }
 276             }
 277             catch (OcException e)
 278             {
 279                 Log.e(TAG, e.getMessage());
 280             }
 281         }
 282 }