resource/examples/mediaserver.cpp

   1 /* ****************************************************************
   2  *
   3  * Copyright 2016 Intel Corporation All Rights Reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  ******************************************************************/
  18
  19 ///
  20 /// This sample provides steps to define an interface for a resource
  21 /// (properties and methods) and host this resource on the server.
  22 ///
  23
  24 #include <functional>
  25 #include <mutex>
  26 #include "platform_features.h"
  27 #include <condition_variable>
  28
  29 #include "OCPlatform.h"
  30 #include "OCApi.h"
  31 #include "ocpayload.h"
  32 #include <windows.h>
  33 #include <objbase.h>
  34
  35 #include <commctrl.h>
  36 #include <mmdeviceapi.h>
  37 #include <endpointvolume.h>
  38 #include <stdio.h>
  39 #include <math.h>       /* log */
  40
  41 #define SAFE_RELEASE(x)  \
  42               if ((x) != NULL)  \
  43                 { (x)->Release(); (x) = NULL; }
  44
  45 using namespace OC;
  46 using namespace std;
  47 namespace PH = std::placeholders;
  48
  49 int gObservation = 0;
  50 void * ChangeMediaRepresentation (void *param);
  51 void * handleSlowResponse (void *param, std::shared_ptr<OCResourceRequest> pRequest);
  52 void playPause(void);
  53 void setVolume(int vol);
  54 int getVolume(void);
  55
  56 // Specifies where to notify all observers or list of observers
  57 // false: notifies all observers
  58 // true: notifies list of observers
  59 bool isListOfObservers = false;
  60
  61 // Specifies secure or non-secure
  62 // false: non-secure resource
  63 // true: secure resource
  64 bool isSecure = false;
  65
  66 /// Specifies whether Entity handler is going to do slow response or not
  67 bool isSlowResponse = false;
  68
  69
  70 // Forward declaring the entityHandler
  71
  72 /// This class represents a single resource named 'MediaResource'. This resource has
  73 /// two simple properties named 'state' and 'volume'
  74
  75 class MediaResource
  76 {
  77
  78 public:
  79     /// Access this property from a TB client
  80     std::string m_name;
  81     bool m_state;
  82     int m_volume;
  83     std::string m_mediaUri;
  84     OCResourceHandle m_resourceHandle;
  85     OCRepresentation m_mediaRep;
  86     ObservationIds m_interestedObservers;
  87
  88 public:
  89     /// Constructor
  90     MediaResource()
  91         :m_name("Media Player"), m_state(false), m_volume(0), m_mediaUri("/a/media"),
  92                 m_resourceHandle(nullptr)
  93     {
  94         // Initialize representation
  95         m_mediaRep.setUri(m_mediaUri);
  96
  97         m_mediaRep.setValue("state", m_state);
  98         m_mediaRep.setValue("volume", m_volume);
  99         m_mediaRep.setValue("name", m_name);
 100     }
 101
 102     /* Note that this does not need to be a member function: for classes you do not have
 103     access to, you can accomplish this with a free function: */
 104
 105     /// This function internally calls registerResource API.
 106     void createResource()
 107     {
 108         OCStackResult result = OC_STACK_OK;
 109
 110         /* Resource Information */
 111         std::string resourceURI = m_mediaUri;
 112         std::string resourceTypeName = "core.media";
 113         std::string resourceInterface = DEFAULT_INTERFACE;
 114
 115         /* Device Information */
 116         result = SetDeviceInfo();
 117         if (OC_STACK_OK != result)
 118         {
 119             cout << "Device information registration was unsuccessful\n";
 120             return;
 121         }
 122
 123         /* Platform Info */
 124         char* platformId = "0A3E0D6F-DBF5-404E-8719-D6880042463A";
 125         char* manufacturerName = "OCF";
 126         char* manufacturerLink = "https://www.iotivity.org";
 127         char* modelNumber = "895";
 128         char* dateOfManufacture = "2016-01-15";
 129         char* platformVersion = "1.0";
 130         char* osVersion = "1.0";
 131         char* hardwareVersion = "1.0";
 132         char* firmwareVersion = "1.0";
 133         char* supportLink = "https://www.iotivity.org";
 134         OCPlatformInfo platformInfo = { platformId,
 135                                         manufacturerName,
 136                                         manufacturerLink,
 137                                         modelNumber,
 138                                         dateOfManufacture,
 139                                         platformVersion,
 140                                         osVersion,
 141                                         hardwareVersion,
 142                                         firmwareVersion,
 143                                         supportLink,
 144                                         nullptr
 145                                       };
 146
 147         result = OCPlatform::registerPlatformInfo(platformInfo);
 148         if (OC_STACK_OK != result)
 149         {
 150             cout << "Platform information registration was unsuccessful\n";
 151             return;
 152         }
 153
 154         // OCResourceProperty is defined ocstack.h
 155         uint8_t resourceProperty;
 156         if (isSecure)
 157         {
 158             resourceProperty = OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE;
 159         }
 160         else
 161         {
 162             resourceProperty = OC_DISCOVERABLE | OC_OBSERVABLE;
 163         }
 164         EntityHandler cb = std::bind(&MediaResource::entityHandler, this, PH::_1);
 165
 166         // This will internally create and register the resource.
 167         result = OCPlatform::registerResource(m_resourceHandle, resourceURI, resourceTypeName,
 168                                               resourceInterface, cb, resourceProperty);
 169         if (OC_STACK_OK != result)
 170         {
 171             cout << "Resource creation was unsuccessful\n";
 172         }
 173     }
 174
 175     OCResourceHandle getHandle()
 176     {
 177         return m_resourceHandle;
 178     }
 179
 180     // Puts representation.
 181     // Gets values from the representation and
 182     // updates the internal state
 183     void put(OCRepresentation& rep)
 184     {
 185         try
 186         {
 187             if (rep.getValue("state", m_state))
 188             {
 189                 cout << "\t\t\t\t" << "state: " << m_state << endl;
 190                 if(m_state)
 191                 {
 192                     playPause();
 193                 }
 194             }
 195             else
 196             {
 197                 cout << "\t\t\t\t" << "state not found in the representation" << endl;
 198             }
 199
 200             if (rep.getValue("volume", m_volume))
 201             {
 202                 cout << "\t\t\t\t" << "volume: " << m_volume << endl;
 203                 if((0 <= m_volume) && (m_volume <= 100))
 204                 {
 205                     setVolume(m_volume);
 206                 }
 207             }
 208             else
 209             {
 210                 cout << "\t\t\t\t" << "volume not found in the representation" << endl;
 211             }
 212         }
 213         catch (exception& e)
 214         {
 215             cout << e.what() << endl;
 216         }
 217
 218     }
 219
 220     // Post representation.
 221     // Post can create new resource or simply act like put.
 222     // Gets values from the representation and
 223     // updates the internal state
 224     OCRepresentation post(OCRepresentation& rep)
 225     {
 226         put(rep);
 227         return get();
 228     }
 229
 230
 231     // gets the updated representation.
 232     // Updates the representation with latest internal state before
 233     // sending out.
 234     OCRepresentation get()
 235     {
 236         m_mediaRep.setValue("state", m_state);
 237         m_mediaRep.setValue("volume", m_volume);
 238
 239         return m_mediaRep;
 240     }
 241
 242     void addType(const std::string& type) const
 243     {
 244         OCStackResult result = OCPlatform::bindTypeToResource(m_resourceHandle, type);
 245         if (OC_STACK_OK != result)
 246         {
 247             cout << "Binding TypeName to Resource was unsuccessful\n";
 248         }
 249     }
 250
 251     void addInterface(const std::string& intf) const
 252     {
 253         OCStackResult result = OCPlatform::bindInterfaceToResource(m_resourceHandle, intf);
 254         if (OC_STACK_OK != result)
 255         {
 256             cout << "Binding TypeName to Resource was unsuccessful\n";
 257         }
 258     }
 259
 260 private:
 261 // This is just a sample implementation of entity handler.
 262 // Entity handler can be implemented in several ways by the manufacturer
 263 OCEntityHandlerResult entityHandler(std::shared_ptr<OCResourceRequest> request)
 264 {
 265     cout << "\tIn Server CPP entity handler:\n";
 266     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 267     if(request)
 268     {
 269         // Get the request type and request flag
 270         std::string requestType = request->getRequestType();
 271         int requestFlag = request->getRequestHandlerFlag();
 272
 273         if(requestFlag & RequestHandlerFlag::RequestFlag)
 274         {
 275             cout << "\t\trequestFlag : Request\n";
 276             auto pResponse = std::make_shared<OC::OCResourceResponse>();
 277             pResponse->setRequestHandle(request->getRequestHandle());
 278             pResponse->setResourceHandle(request->getResourceHandle());
 279
 280             // Check for query params (if any)
 281             QueryParamsMap queries = request->getQueryParameters();
 282
 283             if (!queries.empty())
 284             {
 285                 cout << "\nQuery processing upto entityHandler" << std::endl;
 286             }
 287             for (auto it : queries)
 288             {
 289                 cout << "Query key: " << it.first << " value : " << it.second
 290                         << std::endl;
 291             }
 292
 293             // If the request type is GET
 294             if(requestType == "GET")
 295             {
 296                 cout << "\t\t\trequestType : GET\n";
 297                 if(isSlowResponse) // Slow response case
 298                 {
 299                     static int startedThread = 0;
 300                     if(!startedThread)
 301                     {
 302                         std::thread t(handleSlowResponse, (void *)this, request);
 303                         startedThread = 1;
 304                         t.detach();
 305                     }
 306                     ehResult = OC_EH_SLOW;
 307                 }
 308                 else // normal response case.
 309                 {
 310
 311                     pResponse->setResponseResult(OC_EH_OK);
 312                     pResponse->setResourceRepresentation(get());
 313                     if(OC_STACK_OK == OCPlatform::sendResponse(pResponse))
 314                     {
 315                         ehResult = OC_EH_OK;
 316                     }
 317                 }
 318             }
 319             else if(requestType == "PUT")
 320             {
 321                 cout << "\t\t\trequestType : PUT\n";
 322                 OCRepresentation rep = request->getResourceRepresentation();
 323
 324                 // Do related operations related to PUT request
 325                 // Update the mediaResource
 326                 put(rep);
 327
 328                 pResponse->setResponseResult(OC_EH_OK);
 329                 pResponse->setResourceRepresentation(get());
 330                 if(OC_STACK_OK == OCPlatform::sendResponse(pResponse))
 331                 {
 332                     ehResult = OC_EH_OK;
 333                 }
 334             }
 335             else if(requestType == "POST")
 336             {
 337                 cout << "\t\t\trequestType : POST\n";
 338
 339                 OCRepresentation rep = request->getResourceRepresentation();
 340
 341                 // Do related operations related to POST request
 342                 OCRepresentation rep_post = post(rep);
 343                 pResponse->setResourceRepresentation(rep_post);
 344
 345                 if(rep_post.hasAttribute("createduri"))
 346                 {
 347                     pResponse->setResponseResult(OC_EH_RESOURCE_CREATED);
 348                     pResponse->setNewResourceUri(rep_post.getValue<std::string>("createduri"));
 349                 }
 350                 else
 351                 {
 352                     pResponse->setResponseResult(OC_EH_OK);
 353                 }
 354
 355                 if(OC_STACK_OK == OCPlatform::sendResponse(pResponse))
 356                 {
 357                     ehResult = OC_EH_OK;
 358                 }
 359             }
 360             else if(requestType == "DELETE")
 361             {
 362                 cout << "Delete request received" << endl;
 363             }
 364         }
 365
 366         if(requestFlag & RequestHandlerFlag::ObserverFlag)
 367         {
 368             ObservationInfo observationInfo = request->getObservationInfo();
 369             if(ObserveAction::ObserveRegister == observationInfo.action)
 370             {
 371                 m_interestedObservers.push_back(observationInfo.obsId);
 372             }
 373             else if(ObserveAction::ObserveUnregister == observationInfo.action)
 374             {
 375                 m_interestedObservers.erase(std::remove(
 376                                                             m_interestedObservers.begin(),
 377                                                             m_interestedObservers.end(),
 378                                                             observationInfo.obsId),
 379                                                             m_interestedObservers.end());
 380             }
 381
 382             cout << "\t\trequestFlag : Observer\n";
 383             gObservation = 1;
 384             static int startedThread = 0;
 385
 386             // Observation happens on a different thread in ChangeMediaRepresentation function.
 387             // If we have not created the thread already, we will create one here.
 388
 389             if(!startedThread)
 390             {
 391                 std::thread t(ChangeMediaRepresentation, (void *)this);
 392                 startedThread = 1;
 393                 t.detach();
 394             }
 395
 396             ehResult = OC_EH_OK;
 397         }
 398     }
 399     else
 400     {
 401         cout << "Request invalid" << std::endl;
 402     }
 403
 404     return ehResult;
 405 }
 406
 407 OCStackResult SetDeviceInfo()
 408 {
 409     OCStackResult result = OCPlatform::setPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME,
 410                                                         "IoTivity Media Server");
 411     if (result != OC_STACK_OK)
 412     {
 413         cout << "Failed to set device name" << endl;
 414         return result;
 415     }
 416
 417     result = OCPlatform::setPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "core.1.1.0");
 418     if (result != OC_STACK_OK)
 419     {
 420         cout << "Failed to set spec version" << endl;
 421         return result;
 422     }
 423
 424     return OC_STACK_OK;
 425 }
 426
 427 };
 428
 429 // ChangeMediaRepresentaion is an observation function,
 430 // which notifies any changes to the resource to stack
 431 // via notifyObservers
 432 void * ChangeMediaRepresentation (void *param)
 433 {
 434     int prevVolume = 0;
 435     MediaResource* mediaPtr = (MediaResource*) param;
 436
 437     // This function continuously monitors for the changes
 438     while (1)
 439     {
 440         Sleep(100);
 441
 442         if (gObservation)
 443         {
 444             prevVolume = mediaPtr->m_volume;
 445             mediaPtr->m_volume = getVolume();
 446             if (prevVolume == mediaPtr->m_volume)
 447                 continue;
 448
 449             cout << "Volume changed from " << prevVolume << "% to " << mediaPtr->m_volume << "%\n";
 450
 451             // If under observation if there are any changes to the media resource
 452             // we call notifyObservors
 453             //
 454             // For demostration we are changing the volume value and notifying.
 455
 456             cout << "\nVolume updated to : " << mediaPtr->m_volume << endl;
 457             cout << "Notifying observers with resource handle: " << mediaPtr->getHandle() << endl;
 458
 459             OCStackResult result = OC_STACK_OK;
 460
 461             if(isListOfObservers)
 462             {
 463                 std::shared_ptr<OCResourceResponse> resourceResponse =
 464                             {std::make_shared<OCResourceResponse>()};
 465
 466                 resourceResponse->setResourceRepresentation(mediaPtr->get(), DEFAULT_INTERFACE);
 467
 468                 result = OCPlatform::notifyListOfObservers(  mediaPtr->getHandle(),
 469                                                              mediaPtr->m_interestedObservers,
 470                                                              resourceResponse);
 471             }
 472             else
 473             {
 474                 result = OCPlatform::notifyAllObservers(mediaPtr->getHandle());
 475             }
 476
 477             if(OC_STACK_NO_OBSERVERS == result)
 478             {
 479                 cout << "No More observers, stopping notifications" << endl;
 480                 gObservation = 0;
 481             }
 482         }
 483     }
 484
 485     return NULL;
 486 }
 487
 488 void * handleSlowResponse (void *param, std::shared_ptr<OCResourceRequest> pRequest)
 489 {
 490     // This function handles slow response case
 491     MediaResource* mediaPtr = (MediaResource*) param;
 492     // Induce a case for slow response by using sleep
 493     cout << "SLOW response" << std::endl;
 494     sleep (10);
 495
 496     auto pResponse = std::make_shared<OC::OCResourceResponse>();
 497     pResponse->setRequestHandle(pRequest->getRequestHandle());
 498     pResponse->setResourceHandle(pRequest->getResourceHandle());
 499     pResponse->setResourceRepresentation(mediaPtr->get());
 500
 501     pResponse->setResponseResult(OC_EH_OK);
 502
 503     // Set the slow response flag back to false
 504     isSlowResponse = false;
 505     OCPlatform::sendResponse(pResponse);
 506     return NULL;
 507 }
 508
 509 void PrintUsage()
 510 {
 511     cout << std::endl;
 512     cout << "Usage : mediaserver <value>\n";
 513     cout << "    Default - Non-secure resource and notify all observers\n";
 514     cout << "    1 - Non-secure resource and notify list of observers\n\n";
 515     cout << "    2 - Secure resource and notify all observers\n";
 516     cout << "    3 - Secure resource and notify list of observers\n\n";
 517     cout << "    4 - Non-secure resource, GET slow response, notify all observers\n";
 518 }
 519
 520 static FILE* client_open(const char* /*path*/, const char* mode)
 521 {
 522     return fopen("./oic_svr_db_server.dat", mode);
 523 }
 524
 525 void playPause()
 526 {
 527     INPUT ip;
 528
 529     // Set up a generic keyboard event.
 530     ip.type = INPUT_KEYBOARD;
 531     ip.ki.wScan = 0; // hardware scan code for key
 532     ip.ki.time = 0;
 533     ip.ki.dwExtraInfo = 0;
 534     ip.ki.wVk = VK_MEDIA_PLAY_PAUSE; // virtual-key code for the "a" key
 535     ip.ki.dwFlags = 0; // 0 for key press
 536
 537     SendInput(1, &ip, sizeof(INPUT));
 538     // Release the "Play/Pause" key
 539     ip.ki.dwFlags = KEYEVENTF_KEYUP; // KEYEVENTF_KEYUP for key release
 540     SendInput(1, &ip, sizeof(INPUT));
 541 }
 542
 543 int getVolume()
 544 {
 545     IAudioEndpointVolume *g_pEndptVol = NULL;
 546     HRESULT hr = S_OK;
 547     IMMDeviceEnumerator *pEnumerator = NULL;
 548     IMMDevice *pDevice = NULL;
 549     OSVERSIONINFO VersionInfo;
 550
 551     ZeroMemory(&VersionInfo, sizeof(OSVERSIONINFO));
 552     VersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 553     GetVersionEx(&VersionInfo);
 554     CoInitialize(NULL);
 555
 556     // Get enumerator for audio endpoint devices.
 557     hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
 558                           NULL, CLSCTX_INPROC_SERVER,
 559                           __uuidof(IMMDeviceEnumerator),
 560                           (void**)&pEnumerator);
 561
 562     // Get default audio-rendering device.
 563     hr = pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &pDevice);
 564
 565     hr = pDevice->Activate(__uuidof(IAudioEndpointVolume),
 566                            CLSCTX_ALL, NULL, (void**)&g_pEndptVol);
 567     float currentVal;
 568     hr = g_pEndptVol->GetMasterVolumeLevelScalar(&currentVal);
 569     fflush(stdout); // just in case
 570
 571     SAFE_RELEASE(pEnumerator)
 572     SAFE_RELEASE(pDevice)
 573     SAFE_RELEASE(g_pEndptVol)
 574     CoUninitialize();
 575     return ((int) round(100 * currentVal));
 576
 577 }
 578
 579 void setVolume(int vol)
 580 {
 581     IAudioEndpointVolume *g_pEndptVol = NULL;
 582     HRESULT hr = S_OK;
 583     IMMDeviceEnumerator *pEnumerator = NULL;
 584     IMMDevice *pDevice = NULL;
 585     OSVERSIONINFO VersionInfo;
 586
 587     ZeroMemory(&VersionInfo, sizeof(OSVERSIONINFO));
 588     VersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 589     GetVersionEx(&VersionInfo);
 590     CoInitialize(NULL);
 591
 592     // Get enumerator for audio endpoint devices.
 593     hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
 594                           NULL, CLSCTX_INPROC_SERVER,
 595                           __uuidof(IMMDeviceEnumerator),
 596                           (void**)&pEnumerator);
 597
 598     // Get default audio-rendering device.
 599     hr = pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &pDevice);
 600
 601     hr = pDevice->Activate(__uuidof(IAudioEndpointVolume),
 602                            CLSCTX_ALL, NULL, (void**)&g_pEndptVol);
 603     float got = (float)vol/100.0; // needs to be within 1.0 to 0.0
 604     hr = g_pEndptVol->SetMasterVolumeLevelScalar(got, NULL);
 605     fflush(stdout); // just in case
 606
 607     SAFE_RELEASE(pEnumerator)
 608     SAFE_RELEASE(pDevice)
 609     SAFE_RELEASE(g_pEndptVol)
 610     CoUninitialize();
 611 }
 612
 613 int main(int argc, char* argv[])
 614 {
 615     OCPersistentStorage ps {client_open, fread, fwrite, fclose, unlink };
 616
 617     if (argc == 1)
 618     {
 619         isListOfObservers = false;
 620         isSecure = false;
 621     }
 622     else if (argc == 2)
 623     {
 624         int value = atoi(argv[1]);
 625         switch (value)
 626         {
 627             case 1:
 628                 isListOfObservers = true;
 629                 isSecure = false;
 630                 break;
 631             case 2:
 632                 isListOfObservers = false;
 633                 isSecure = true;
 634                 break;
 635             case 3:
 636                 isListOfObservers = true;
 637                 isSecure = true;
 638                 break;
 639             case 4:
 640                 isSlowResponse = true;
 641                 break;
 642             default:
 643                 PrintUsage();
 644                 break;
 645        }
 646      }
 647     else
 648     {
 649         PrintUsage();
 650         return -1;
 651     }
 652
 653     // Create PlatformConfig object
 654     PlatformConfig cfg {
 655         OC::ServiceType::InProc,
 656         OC::ModeType::Server,
 657         "0.0.0.0", // By setting to "0.0.0.0", it binds to all available interfaces
 658         0,         // Uses randomly available port
 659         OC::QualityOfService::LowQos,
 660         &ps
 661     };
 662
 663     OCPlatform::Configure(cfg);
 664     try
 665     {
 666         // Create the instance of the resource class
 667         // (in this case instance of class 'MediaResource').
 668         MediaResource myMedia;
 669
 670         // Invoke createResource function of class media.
 671         myMedia.createResource();
 672         cout << "Created resource." << std::endl;
 673
 674         // A condition variable will free the mutex it is given, then do a non-
 675         // intensive block until 'notify' is called on it.  In this case, since we
 676         // don't ever call cv.notify, this should be a non-processor intensive version
 677         // of while(true);
 678         std::mutex blocker;
 679         std::condition_variable cv;
 680         std::unique_lock<std::mutex> lock(blocker);
 681         cout <<"Waiting" << std::endl;
 682         cv.wait(lock, []{return false;});
 683     }
 684     catch(OCException &e)
 685     {
 686         cout << "OCException in main : " << e.what() << endl;
 687     }
 688
 689     // No explicit call to stop the platform.
 690     // When OCPlatform::destructor is invoked, internally we do platform cleanup
 691
 692     return 0;
 693 }
 694