void SipPublishContentMgr::getContentChangeObserver(const char* eventType, SipPublisherContentChangeCallback& callbackFunction, void*& applicationData) { Os::Logger::instance().log(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::getContentChangeObserver eventType '%s'", eventType); UtlString eventTypeString(eventType); lock(); PublishCallbackContainer* callbackEntry = dynamic_cast <PublishCallbackContainer*> (mEventContentCallbacks.find(&eventTypeString)); if (callbackEntry) { callbackFunction = callbackEntry->mpCallback; applicationData = callbackEntry->mpApplicationData; } else { callbackFunction = NULL; applicationData = NULL; } unlock(); return; }
UtlBoolean SipPublishContentMgr::removeContentChangeObserver(const char* eventType, void*& applicationData, SipPublisherContentChangeCallback& callbackFunction) { OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::removeContentChangeObserver eventType '%s', callbackFunction %p", eventType, &callbackFunction); UtlBoolean callbackRemoved = FALSE; UtlString eventTypeString(eventType); PublishCallbackContainer* callbackEntry = NULL; lock(); // eventType must be defined if(eventType == NULL || *eventType == 0) { OsSysLog::add(FAC_SIP, PRI_ERR, "SipPublishContentMgr::setContentChangeObserver ignored, event type not set."); } // There should not be a callback set, need to unset first else if((callbackEntry = (PublishCallbackContainer*) mEventContentCallbacks.remove(&eventTypeString))) { callbackRemoved = TRUE; callbackFunction = callbackEntry->mpCallback; applicationData = callbackEntry->mpApplicationData; delete callbackEntry; callbackEntry = NULL; } else { OsSysLog::add(FAC_SIP, PRI_ERR, "SipPublishContentMgr::setContentChangeObserver ignored, no callback exists for event: %s", eventType ? eventType : "<null>"); } unlock(); return (callbackRemoved); }
UtlBoolean SipPublishContentMgr::setContentChangeObserver(const char* eventType, void* applicationData, SipPublisherContentChangeCallback callbackFunction) { OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::setContentChangeObserver eventType '%s', callbackFunction %p", eventType, callbackFunction); UtlBoolean callbackSet = FALSE; UtlString eventTypeString(eventType); lock(); // eventTypeKey and eventType must be defined if(eventType == NULL || *eventType == 0) { OsSysLog::add(FAC_SIP, PRI_ERR, "SipPublishContentMgr::setContentChangeObserver ignored, event type not set."); } // There should not be a callback set, need to unset first else if((mEventContentCallbacks.find(&eventTypeString))) { OsSysLog::add(FAC_SIP, PRI_ERR, "SipPublishContentMgr::setContentChangeObserver ignored, callback already exists for event: %s", eventType ? eventType : "<null>"); } else { callbackSet = TRUE; PublishCallbackContainer* callbackEntry = new PublishCallbackContainer(); *((UtlString*)callbackEntry) = eventType; callbackEntry->mpApplicationData = applicationData; callbackEntry->mpCallback = callbackFunction; mEventContentCallbacks.insert(callbackEntry); } unlock(); return (callbackSet); }
void SipPublishContentMgr::setContentChangeObserver(const char* eventType, SipPublisherContentChangeCallback callbackFunction, void* applicationData) { Os::Logger::instance().log(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::setContentChangeObserver eventType '%s', callbackFunction %p, applicationData = %p", eventType, callbackFunction, applicationData); UtlString eventTypeString(eventType); lock(); // eventType must be defined if (!eventTypeString.isNull()) { // Delete any existing callback. mEventContentCallbacks.destroy(&eventTypeString); // Insert the new callback, if it is not NULL. if (callbackFunction) { mEventContentCallbacks.insert( new PublishCallbackContainer(eventTypeString, callbackFunction, applicationData)); } } else { Os::Logger::instance().log(FAC_SIP, PRI_ERR, "SipPublishContentMgr::setContentChangeObserver " "ignored, eventType is null."); } unlock(); return; }
UtlBoolean SipPublishContentMgr::publish(const char* resourceId, const char* eventTypeKey, const char* eventType, int numContentTypes, HttpBody* eventContent[], int maxOldContentTypes, int& numOldContentTypes, HttpBody* oldEventContent[]) { #ifdef TEST_PRINT osPrintf("SipPublishContentMgr::publish(%s, %s, %s, %d, [%p], ...)\n", resourceId, eventTypeKey, eventType, numContentTypes, eventContent[0]); #endif UtlBoolean contentAdded = FALSE; UtlBoolean resourceIdProvided = FALSE; UtlString key; if(resourceId && *resourceId) { resourceIdProvided = TRUE; key = resourceId; } if(eventTypeKey) { key.append(eventTypeKey); } int numOld = 0; lock(); PublishContentContainer* container = NULL; if(resourceIdProvided) { // See if resource specific content already exists container = (PublishContentContainer*) mContentEntries.find(&key); } else { // See if default content already exists container = (PublishContentContainer*) mDefaultContentEntries.find(&key); } if(container == NULL && numContentTypes > 0) { container = new PublishContentContainer(); *((UtlString*)container) = key; container->mResourceId = ""; container->mEventTypeKey = eventTypeKey; numOldContentTypes = 0; if(resourceIdProvided) { // Add resource specific content mContentEntries.insert(container); } else { // Add default content mDefaultContentEntries.insert(container); } } // No existing content and no new content else if(container == NULL && numContentTypes <= 0) { } // The content default for this event type already existed else { numOld = container->mEventContent.entries(); if(numOld <= maxOldContentTypes) { // Remove the old content numOldContentTypes = numOld; for(int index = 0; index < numOld; index++) { oldEventContent[index] = (HttpBody*) container->mEventContent.first(); container->mEventContent.remove(oldEventContent[index]); } if(numContentTypes <= 0) { // Remove and delete the container if(resourceIdProvided) { // Remove resource specific content mContentEntries.remove(container); } else { // Remove default content mDefaultContentEntries.remove(container); } delete container; container = NULL; } } } // If there is old content and we did not get a big enough array // to put the old content in, don't do anything if(numOld <= maxOldContentTypes) { // Add the new content for(int index = 0; index < numContentTypes; index++) { container->mEventContent.append(eventContent[index]); } contentAdded = TRUE; // See if there is a observer for the content change UtlString eventTypeString(eventType); PublishCallbackContainer* callbackContainer = (PublishCallbackContainer*) mEventContentCallbacks.find(&eventTypeString); if(callbackContainer && callbackContainer->mpCallback) { (callbackContainer->mpCallback)(callbackContainer->mpApplicationData, resourceId, eventTypeKey, eventTypeString, !resourceIdProvided); } } unlock(); return(contentAdded); }
void SipPublishContentMgr::unpublish(const char* resourceId, const char* eventTypeKey, const char* eventType, const char* reason) { Os::Logger::instance().log(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::unpublish resourceId '%s', eventTypeKey '%s', eventType '%s', reason '%s'", resourceId ? resourceId : "(null)", eventTypeKey, eventType, reason ? reason : "(null)"); // Construct the key to look up. UtlString key; key.append(resourceId); key.append(CONTENT_KEY_SEPARATOR); key.append(eventTypeKey); lock(); // Look up the key in the specific or default entries, as appropriate. if (resourceId) { PublishContentContainer* content = dynamic_cast <PublishContentContainer*> (mContentEntries.remove(&key)); PublishContentContainer* partialContent = dynamic_cast <PublishContentContainer*> (mPartialContentEntries.remove(&key)); // Call the default content constructors, if available. // Construct the key for the default data. UtlString default_key; default_key.append(CONTENT_KEY_SEPARATOR); default_key.append(eventTypeKey); // If it exists, call it to publish full content for this resource/event. SipPublishContentMgrDefaultConstructor* constructor = dynamic_cast <SipPublishContentMgrDefaultConstructor*> (mDefaultContentConstructors.findValue(&default_key)); if (constructor) { constructor->generateDefaultContent(this, resourceId, eventTypeKey, eventType); } // If it exists, call it to publish partial content for this resource/event. constructor = dynamic_cast <SipPublishContentMgrDefaultConstructor*> (mDefaultPartialContentConstructors.findValue(&default_key)); if (constructor) { constructor->generateDefaultContent(this, resourceId, eventTypeKey, eventType); } // Is there a callback for this eventType? (Probably so.) UtlString eventTypeString(eventType); PublishCallbackContainer* callbackContainer = dynamic_cast <PublishCallbackContainer*> (mEventContentCallbacks.find(&eventTypeString)); if (callbackContainer) { // See if resource-specific (full) content exists now. PublishContentContainer* newContent = dynamic_cast <PublishContentContainer*> (mContentEntries.find(&key)); // If no (full) content was generated, check if (fixed) default content exists. PublishContentContainer* defaultContent = NULL; if (!newContent) { defaultContent = dynamic_cast <PublishContentContainer*> (mDefaultContentEntries.find(&default_key)); } // Now, newContent is non-NULL if default content exists for // 'key', which means that the resource still has // publishable content. if (newContent || defaultContent) { // Replace the new content for the resource with the previous content. if (newContent) { mContentEntries.removeReference(newContent); } PublishContentContainer* newPartialContent = dynamic_cast <PublishContentContainer*> (mPartialContentEntries.remove(&key)); // Insert the previous content for the resource. if (content) { mContentEntries.insert(content); } if (partialContent) { mPartialContentEntries.insert(partialContent); } // Do a "publish" callback. (callbackContainer->mpCallback)(callbackContainer->mpApplicationData, resourceId, eventTypeKey, eventTypeString, NULL); // Remove the previous content again. // Insert the previous content for the resource. if (content) { mContentEntries.removeReference(content); } if (partialContent) { mPartialContentEntries.removeReference(partialContent); } // Insert the new content again. if (newContent) { mContentEntries.insert(newContent); } if (newPartialContent) { mContentEntries.insert(newPartialContent); } } else { // No publishable content, so do an "unpublish" callback. (callbackContainer->mpCallback)(callbackContainer->mpApplicationData, resourceId, eventTypeKey, eventTypeString, reason); } } // Delete the old content containers. if (content) { delete content; } if (partialContent) { delete partialContent; } } else { // Remove default content. mDefaultContentEntries.destroy(&key); // Remove any default constructor. mDefaultContentConstructors.destroy(&key); } unlock(); }
void SipPublishContentMgr::publish(const char* resourceId, const char* eventTypeKey, const char* eventType, int numContentTypes, HttpBody* eventContent[], UtlBoolean fullState, UtlBoolean noNotify) { Os::Logger::instance().log(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::publish resourceId '%s', eventTypeKey '%s', eventType '%s', numContentTypes %d, noNotify %d, fullState %d", resourceId ? resourceId : "(null)", eventTypeKey, eventType, numContentTypes, noNotify, fullState); if (numContentTypes < 1) { Os::Logger::instance().log(FAC_SIP, PRI_ERR, "SipPublishContentMgr::publish " "No content bodies supplied for resourceId '%s', " "eventTypeKey '%s', fullState %d", resourceId? resourceId : "(null)", eventTypeKey, fullState); } // Construct the key to look up. UtlString key; key.append(resourceId); key.append(CONTENT_KEY_SEPARATOR); key.append(eventTypeKey); lock(); // Determine the storage we will be using. UtlHashBag* pContent; // resourceId can be NULL if we are called from ::publishDefault() if (resourceId) { if (fullState) { // Full dialog events pContent = &mContentEntries; } else { // Partial dialog events pContent = &mPartialContentEntries; } } else { // Default dialog events if (fullState) { pContent = &mDefaultContentEntries; } else { pContent = &mDefaultPartialContentEntries; } } // Look up the key in the specific or default entries, as appropriate. PublishContentContainer* container = dynamic_cast <PublishContentContainer*> (pContent->find(&key)); // If not found, create a container. if (container == NULL) { container = new PublishContentContainer(key); // Save the container in the appropriate hash. pContent->insert(container); } // The content for this event type already existed else { // Remove the old content container->mEventContent.destroyAll(); } // Add the new content for (int index = 0; index < numContentTypes; index++) { Os::Logger::instance().log(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::publish eventContent[%d] = %p, key = '%s', content type = '%s', getBytes() = %p '%s'", index, eventContent[index], key.data(), eventContent[index]->data(), eventContent[index]->getBytes(), eventContent[index]->getBytes()); container->mEventContent.append(eventContent[index]); } // Don't call the observers if noNotify is set or if this is default content. if (!noNotify && resourceId) { // Call the observer for the content change, if any. UtlString eventTypeString(eventType); PublishCallbackContainer* callbackContainer = dynamic_cast <PublishCallbackContainer*> (mEventContentCallbacks.find(&eventTypeString)); if (callbackContainer) { (callbackContainer->mpCallback)(callbackContainer->mpApplicationData, resourceId, eventTypeKey, eventTypeString, NULL); } } unlock(); }
void SipPublishContentMgr::unpublish(const char* resourceId, const char* eventTypeKey, const char* eventType) { OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::unpublish resourceId '%s', eventTypeKey '%s', eventType '%s'", resourceId, eventTypeKey, eventType); UtlBoolean resourceIdProvided = resourceId && *resourceId; // Construct the key to look up. UtlString key; if(resourceIdProvided) { key = resourceId; } if(eventTypeKey) { key.append(eventTypeKey); } lock(); // Look up the key in the specific or default entries, as appropriate. PublishContentContainer* container; if (resourceIdProvided) { container = dynamic_cast <PublishContentContainer*>(mContentEntries.find(&key)); if (container) { container->mEventContent.destroyAll(); container->mEventVersion.destroyAll(); mContentEntries.destroy(container); } container = dynamic_cast <PublishContentContainer*>(mPartialContentEntries.find(&key)); if (container) { container->mEventContent.destroyAll(); container->mEventVersion.destroyAll(); mPartialContentEntries.destroy(container); } } else { container = dynamic_cast <PublishContentContainer*>(mDefaultContentEntries.find(&key)); if (container) { container->mEventContent.destroyAll(); container->mEventVersion.destroyAll(); mDefaultContentEntries.destroy(container); } // Remove any default constructor. mDefaultContentConstructors.destroy(&key); } // Call the observer for the content change, if any, unless this // is default content. if (resourceIdProvided) { UtlString eventTypeString(eventType); PublishCallbackContainer* callbackContainer = dynamic_cast <PublishCallbackContainer*> (mEventContentCallbacks.find(&eventTypeString)); if(callbackContainer && callbackContainer->mpCallback) { (callbackContainer->mpCallback)(callbackContainer->mpApplicationData, resourceId, eventTypeKey, eventTypeString); } } unlock(); }
void SipPublishContentMgr::publish(const char* resourceId, const char* eventTypeKey, const char* eventType, int numContentTypes, HttpBody* eventContent[], const int eventVersion[], UtlBoolean noNotify, UtlBoolean fullState) { OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::publish resourceId '%s', eventTypeKey '%s', eventType '%s', numContentTypes %d, noNotify %d, fullState %d", resourceId, eventTypeKey, eventType, numContentTypes, noNotify, fullState); UtlBoolean resourceIdProvided = resourceId && *resourceId; // Construct the key to look up. UtlString key; if(resourceIdProvided) { key = resourceId; } if(eventTypeKey) { key.append(eventTypeKey); } lock(); // Determine the type of storage we will be using UtlHashBag* pContent; if (resourceIdProvided) { if (fullState) { // Full dialog events pContent = &mContentEntries; } else { // Partial dialog events pContent = &mPartialContentEntries; } } else { // Default dialog events pContent = &mDefaultContentEntries; } // Look up the key in the specific or default entries, as appropriate. PublishContentContainer* container = dynamic_cast <PublishContentContainer*> (pContent->find(&key)); // If not found, create a container. if(container == NULL) { container = new PublishContentContainer(); *((UtlString*) container) = key; // Save the container in the appropriate hash. pContent->insert(container); } // The content for this event type already existed else { // Remove the old content container->mEventContent.destroyAll(); container->mEventVersion.destroyAll(); } // Add the new content for (int index = 0; index < numContentTypes; index++) { OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipPublishContentMgr::publish eventContent[%d] = %p, key = '%s', content type = '%s', version = %d, getBytes() = %p '%s'", index, eventContent[index], key.data(), eventContent[index]->data(), eventVersion[index], eventContent[index]->getBytes(), eventContent[index]->getBytes()); container->mEventContent.append(eventContent[index]); container->mEventVersion.append(new UtlInt(eventVersion[index])); } // Don't call the observers if noNotify is set or if this is default content. if (!noNotify && resourceIdProvided) { // Call the observer for the content change, if any. UtlString eventTypeString(eventType); PublishCallbackContainer* callbackContainer = dynamic_cast <PublishCallbackContainer*> (mEventContentCallbacks.find(&eventTypeString)); if(callbackContainer && callbackContainer->mpCallback) { (callbackContainer->mpCallback)(callbackContainer->mpApplicationData, resourceId, eventTypeKey, eventTypeString); } } unlock(); }