void CAddonCallbacksPVR::PVRTransferTimerEntry(void *addonData, const ADDON_HANDLE handle, const PVR_TIMER *timer)
{
if (!handle)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
CPVRClient *client = GetPVRClient(addonData);
CPVRTimers *xbmcTimers = static_cast<CPVRTimers *>(handle->dataAddress);
if (!timer || !client || !xbmcTimers)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
CPVRChannelPtr channel = g_PVRChannelGroups->GetByUniqueID(timer->iClientChannelUid, client->GetID());
if (!channel)
{
CLog::Log(LOGERROR, "PVR - %s - cannot find channel %d on client %d", __FUNCTION__, timer->iClientChannelUid, client->GetID());
return;
}
/* transfer this entry to the timers container */
CPVRTimerInfoTag transferTimer(*timer, channel, client->GetID());
xbmcTimers->UpdateFromClient(transferTimer);
}
void CAddonHelpers_PVR::PVRTransferChannelEntry(void *addonData, const PVRHANDLE handle, const PVR_CHANNEL *channel)
{
CAddonHelpers* addon = (CAddonHelpers*) addonData;
if (addon == NULL || handle == NULL || channel == NULL)
{
CLog::Log(LOGERROR, "PVR: PVRTransferChannelEntry is called with NULL-Pointer!!!");
return;
}
CPVRClient* client = (CPVRClient*) handle->CALLER_ADDRESS;
CPVRChannelGroupInternal *xbmcChannels = (CPVRChannelGroupInternal*) handle->DATA_ADDRESS;
CPVRChannel channelTag(channel->radio);
channelTag.SetClientChannelNumber(channel->number);
channelTag.SetClientID(client->GetClientID());
channelTag.SetUniqueID(channel->uid);
channelTag.SetChannelName(channel->name);
channelTag.SetClientChannelName(channel->callsign);
channelTag.SetIconPath(channel->iconpath);
channelTag.SetEncryptionSystem(channel->encryption);
channelTag.SetHidden(channel->hide);
channelTag.SetRecording(channel->recording);
channelTag.SetInputFormat(channel->input_format);
channelTag.SetStreamURL(channel->stream_url);
xbmcChannels->UpdateChannel(channelTag);
}
void CAddonCallbacksPVR::PVRRecording(void *addonData, const char *strName, const char *strFileName, bool bOnOff)
{
CPVRClient *client = GetPVRClient(addonData);
if (!client || !strFileName)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
CStdString strLine1;
if (bOnOff)
strLine1 = StringUtils::Format(g_localizeStrings.Get(19197).c_str(), client->Name().c_str());
else
strLine1 = StringUtils::Format(g_localizeStrings.Get(19198).c_str(), client->Name().c_str());
CStdString strLine2;
if (strName)
strLine2 = strName;
else if (strFileName)
strLine2 = strFileName;
/* display a notification for 5 seconds */
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, strLine1, strLine2, 5000, false);
CLog::Log(LOGDEBUG, "PVR - %s - recording %s on client '%s'. name='%s' filename='%s'",
__FUNCTION__, bOnOff ? "started" : "finished", client->Name().c_str(), strName, strFileName);
}
void CAddonCallbacksPVR::PVRTransferTimerEntry(void *addonData, const PVR_HANDLE handle, const PVR_TIMER *timer)
{
CAddonCallbacks* addon = (CAddonCallbacks*) addonData;
if (addon == NULL || handle == NULL || timer == NULL)
{
CLog::Log(LOGERROR, "CAddonCallbacksPVR - %s - called with a null pointer", __FUNCTION__);
return;
}
CPVRTimers *xbmcTimers = (CPVRTimers*) handle->dataAddress;
CPVRClient* client = (CPVRClient*) handle->callerAddress;
CPVRChannel *channel = (CPVRChannel *) g_PVRChannelGroups->GetByUniqueID(timer->iClientChannelUid, client->GetClientID());
if (channel == NULL)
{
CLog::Log(LOGERROR, "CAddonCallbacksPVR - %s - cannot find channel %d on client %d",
__FUNCTION__, timer->iClientChannelUid, client->GetClientID());
return;
}
CPVRTimerInfoTag tag(*timer, channel, client->GetClientID());
/* transfer this entry to the timers container */
xbmcTimers->UpdateFromClient(tag);
}
void CAddonHelpers_PVR::PVRTransferRecordingEntry(void *addonData, const PVRHANDLE handle, const PVR_RECORDINGINFO *recording)
{
CAddonHelpers* addon = (CAddonHelpers*) addonData;
if (addon == NULL || handle == NULL || recording == NULL)
{
CLog::Log(LOGERROR, "PVR: PVRTransferRecordingEntry is called with NULL-Pointer!!!");
return;
}
CPVRClient* client = (CPVRClient*) handle->CALLER_ADDRESS;
CPVRRecordings *xbmcRecordings = (CPVRRecordings*) handle->DATA_ADDRESS;
CPVRRecordingInfoTag tag;
tag.SetClientIndex(recording->index);
tag.SetClientID(client->GetClientID());
tag.SetTitle(recording->title);
tag.SetRecordingTime(recording->recording_time);
tag.SetDuration(CDateTimeSpan(0, 0, recording->duration / 60, recording->duration % 60));
tag.SetPriority(recording->priority);
tag.SetLifetime(recording->lifetime);
tag.SetDirectory(recording->directory);
tag.SetPlot(recording->description);
tag.SetPlotOutline(recording->subtitle);
tag.SetStreamURL(recording->stream_url);
tag.SetChannelName(recording->channel_name);
xbmcRecordings->push_back(tag);
return;
}
bool CPVRDatabase::Delete(const CPVRClient &client)
{
/* invalid client uid */
if (client.ID().IsEmpty())
{
CLog::Log(LOGERROR, "PVR - %s - invalid client uid", __FUNCTION__);
return false;
}
CStdString strWhereClause = FormatSQL("sUid = '%s'", client.ID().c_str());
return DeleteValues("clients", strWhereClause);
}
void CAddonCallbacksPVR::PVRTriggerEpgUpdate(void *addonData, unsigned int iChannelUid)
{
// get the client
CPVRClient *client = GetPVRClient(addonData);
if (!client)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
g_EpgContainer.UpdateRequest(client->GetID(), iChannelUid);
}
bool CPVRDatabase::DeleteClientChannels(const CPVRClient &client)
{
/* invalid client Id */
if (client.GetID() <= 0)
{
CLog::Log(LOGERROR, "PVR - %s - invalid client id: %i", __FUNCTION__, client.GetID());
return false;
}
CLog::Log(LOGDEBUG, "PVR - %s - deleting all channels from client '%i' from the database", __FUNCTION__, client.GetID());
CStdString strWhereClause = FormatSQL("iClientId = %u", client.GetID());
return DeleteValues("channels", strWhereClause);
}
void CAddonCallbacksPVR::PVRTransferRecordingEntry(void *addonData, const PVR_HANDLE handle, const PVR_RECORDING *recording)
{
CPVRClient *client = GetPVRClient(addonData);
CPVRRecordings *xbmcRecordings = static_cast<CPVRRecordings *>(handle->dataAddress);
if (!handle || !recording || !client || !xbmcRecordings)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
/* transfer this entry to the recordings container */
xbmcRecordings->UpdateFromClient(CPVRRecording(*recording, client->GetID()));
}
void CAddonCallbacksPVR::PVRTransferChannelEntry(void *addonData, const PVR_HANDLE handle, const PVR_CHANNEL *channel)
{
CPVRClient *client = GetPVRClient(addonData);
CPVRChannelGroupInternal *xbmcChannels = static_cast<CPVRChannelGroupInternal *>(handle->dataAddress);
if (!handle || !channel || !client || !xbmcChannels)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
/* transfer this entry to the internal channels group */
xbmcChannels->UpdateFromClient(CPVRChannel(*channel, client->GetID()));
}
bool CPVRDatabase::Delete(const CPVRClient &client)
{
if (client.GetID() == PVR_INVALID_CLIENT_ID)
return false;
CLog::LogFC(LOGDEBUG, LOGPVR, "Deleting client '%s' from the database", client.ID().c_str());
CSingleLock lock(m_critSection);
Filter filter;
filter.AppendWhere(PrepareSQL("idClient = '%i'", client.GetID()));
return DeleteValues("clients", filter);
}
bool CPVRDatabase::Delete(const CPVRClient &client)
{
/* invalid client uid */
if (client.ID().empty())
{
CLog::Log(LOGERROR, "PVR - %s - invalid client uid", __FUNCTION__);
return false;
}
Filter filter;
filter.AppendWhere(PrepareSQL("sUid = '%s'", client.ID().c_str()));
return DeleteValues("clients", filter);
}
bool CPVRDatabase::Persist(const CPVRClient &client)
{
if (client.GetID() == PVR_INVALID_CLIENT_ID)
return false;
CLog::LogFC(LOGDEBUG, LOGPVR, "Persisting client '%s' to database", client.ID().c_str());
CSingleLock lock(m_critSection);
const std::string strQuery = PrepareSQL("REPLACE INTO clients (idClient, iPriority) VALUES (%i, %i);",
client.GetID(), client.GetPriority());
return ExecuteQuery(strQuery);
}
void CAddonCallbacksPVR::PVRTransferChannelGroupMember(void *addonData, const ADDON_HANDLE handle, const PVR_CHANNEL_GROUP_MEMBER *member)
{
if (!handle)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
CPVRClient *client = GetPVRClient(addonData);
CPVRChannelGroup *group = static_cast<CPVRChannelGroup *>(handle->dataAddress);
if (!member || !client || !group)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
CPVRChannelPtr channel = g_PVRChannelGroups->GetByUniqueID(member->iChannelUniqueId, client->GetID());
if (!channel)
{
CLog::Log(LOGERROR, "PVR - %s - cannot find group '%s' or channel '%d'", __FUNCTION__, member->strGroupName, member->iChannelUniqueId);
}
else if (group->IsRadio() == channel->IsRadio())
{
/* transfer this entry to the group */
group->AddToGroup(channel, member->iChannelNumber);
}
}
bool CPVRDatabase::DeleteClientChannels(const CPVRClient &client)
{
/* invalid client Id */
if (client.GetID() <= 0)
{
CLog::Log(LOGERROR, "PVR - %s - invalid client id: %i", __FUNCTION__, client.GetID());
return false;
}
CLog::Log(LOGDEBUG, "PVR - %s - deleting all channels from client '%i' from the database", __FUNCTION__, client.GetID());
Filter filter;
filter.AppendWhere(PrepareSQL("iClientId = %u", client.GetID()));
return DeleteValues("channels", filter);
}
void CAddonCallbacksPVR::PVRTransferChannelEntry(void *addonData, const PVR_HANDLE handle, const PVR_CHANNEL *channel)
{
CAddonCallbacks* addon = (CAddonCallbacks*) addonData;
if (addon == NULL || handle == NULL || channel == NULL)
{
CLog::Log(LOGERROR, "CAddonCallbacksPVR - %s - called with a null pointer", __FUNCTION__);
return;
}
CPVRClient* client = (CPVRClient*) handle->callerAddress;
CPVRChannelGroupInternal *xbmcChannels = (CPVRChannelGroupInternal*) handle->dataAddress;
CPVRChannel channelTag(*channel, client->GetClientID());
/* transfer this entry to the internal channels group */
xbmcChannels->UpdateFromClient(channelTag);
}
void CAddonCallbacksPVR::PVRTransferRecordingEntry(void *addonData, const PVR_HANDLE handle, const PVR_RECORDING *recording)
{
CAddonCallbacks* addon = (CAddonCallbacks*) addonData;
if (addon == NULL || handle == NULL || recording == NULL)
{
CLog::Log(LOGERROR, "CAddonCallbacksPVR - %s - called with a null pointer", __FUNCTION__);
return;
}
CPVRClient* client = (CPVRClient*) handle->callerAddress;
CPVRRecordings *xbmcRecordings = (CPVRRecordings*) handle->dataAddress;
CPVRRecording tag(*recording, client->GetClientID());
/* transfer this entry to the recordings container */
xbmcRecordings->UpdateFromClient(tag);
}
int CPVRDatabase::GetPriority(const CPVRClient &client)
{
if (client.GetID() == PVR_INVALID_CLIENT_ID)
return 0;
CLog::LogFC(LOGDEBUG, LOGPVR, "Getting priority for client '%s' from the database", client.ID().c_str());
CSingleLock lock(m_critSection);
const std::string strWhereClause = PrepareSQL("idClient = '%i'", client.GetID());
const std::string strValue = GetSingleValue("clients", "iPriority", strWhereClause);
if (strValue.empty())
return 0;
return atoi(strValue.c_str());
}
void CAddonHelpers_PVR::PVRAddMenuHook(void *addonData, PVR_MENUHOOK *hook)
{
CAddonHelpers* addon = (CAddonHelpers*) addonData;
if (addon == NULL || hook == NULL)
{
CLog::Log(LOGERROR, "PVR: PVRAddMenuHook is called with NULL-Pointer!!!");
return;
}
CAddonHelpers_PVR* addonHelper = addon->GetHelperPVR();
CPVRClient* client = (CPVRClient*) addonHelper->m_addon;
PVR_MENUHOOKS *hooks = client->GetMenuHooks();
PVR_MENUHOOK hookInt;
hookInt.hook_id = hook->hook_id;
hookInt.string_id = hook->string_id;
hooks->push_back(hookInt);
}
void CAddonHelpers_PVR::PVRTransferEpgEntry(void *addonData, const PVRHANDLE handle, const PVR_PROGINFO *epgentry)
{
CAddonHelpers* addon = (CAddonHelpers*) addonData;
if (addon == NULL || handle == NULL || epgentry == NULL)
{
CLog::Log(LOGERROR, "PVR: PVRTransferEpgEntry is called with NULL-Pointer!!!");
return;
}
CPVREpg *xbmcEpg = (CPVREpg*) handle->DATA_ADDRESS;
PVR_PROGINFO *epgentry2 = (PVR_PROGINFO*) epgentry;
CPVRClient* client = (CPVRClient*) handle->CALLER_ADDRESS;
epgentry2->starttime += client->GetTimeCorrection();
epgentry2->endtime += client->GetTimeCorrection();
xbmcEpg->UpdateEntry(epgentry2, handle->DATA_IDENTIFIER == 1);
return;
}
void CAddonCallbacksPVR::PVREpgEventStateChange(void* addonData, EPG_TAG* tag, unsigned int iUniqueChannelId, EPG_EVENT_STATE newState)
{
CPVRClient *client = GetPVRClient(addonData);
if (!client || !tag)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
CLog::Log(LOGDEBUG, "PVR - %s - state for epg event '%d' on channel '%d' on client '%s' changed to '%d'.",
__FUNCTION__, tag->iUniqueBroadcastId, iUniqueChannelId, client->Name().c_str(), newState);
static CCriticalSection queueMutex;
static std::vector<EpgEventStateChange> queuedChanges;
// during Kodi startup, addons may push updates very early, even before EPGs are ready to use.
if (g_PVRManager.EpgsCreated())
{
{
// deliver queued changes, if any. discard event if delivery fails.
CSingleLock lock(queueMutex);
if (!queuedChanges.empty())
CLog::Log(LOGNOTICE, "PVR - %s - processing %ld queued epg event changes.", __FUNCTION__, queuedChanges.size());
while (!queuedChanges.empty())
{
auto it = queuedChanges.begin();
UpdateEpgEvent(*it, true);
queuedChanges.erase(it);
}
}
// deliver current change.
UpdateEpgEvent(EpgEventStateChange(client->GetID(), iUniqueChannelId, tag, newState), false);
}
else
{
// queue for later delivery.
CSingleLock lock(queueMutex);
queuedChanges.push_back(EpgEventStateChange(client->GetID(), iUniqueChannelId, tag, newState));
}
}
void CAddonCallbacksPVR::PVRAddMenuHook(void *addonData, PVR_MENUHOOK *hook)
{
CPVRClient *client = GetPVRClient(addonData);
if (!hook || !client)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
PVR_MENUHOOKS *hooks = client->GetMenuHooks();
if (hooks)
{
PVR_MENUHOOK hookInt;
hookInt.iHookId = hook->iHookId;
hookInt.iLocalizedStringId = hook->iLocalizedStringId;
/* add this new hook */
hooks->push_back(hookInt);
}
}
void CAddonCallbacksPVR::PVRAddMenuHook(void *addonData, PVR_MENUHOOK *hook)
{
CAddonCallbacks* addon = (CAddonCallbacks*) addonData;
if (addon == NULL || hook == NULL)
{
CLog::Log(LOGERROR, "CAddonCallbacksPVR - %s - called with a null pointer", __FUNCTION__);
return;
}
CAddonCallbacksPVR* addonHelper = addon->GetHelperPVR();
CPVRClient* client = (CPVRClient*) addonHelper->m_addon;
PVR_MENUHOOKS *hooks = client->GetMenuHooks();
PVR_MENUHOOK hookInt;
hookInt.iHookId = hook->iHookId;
hookInt.iLocalizedStringId = hook->iLocalizedStringId;
/* add this new hook */
hooks->push_back(hookInt);
}
void CAddonHelpers_PVR::PVRTransferTimerEntry(void *addonData, const PVRHANDLE handle, const PVR_TIMERINFO *timer)
{
CAddonHelpers* addon = (CAddonHelpers*) addonData;
if (addon == NULL || handle == NULL || timer == NULL)
{
CLog::Log(LOGERROR, "PVR: PVRTransferTimerEntry is called with NULL-Pointer!!!");
return;
}
CPVRTimers *xbmcTimers = (CPVRTimers*) handle->DATA_ADDRESS;
CPVRClient* client = (CPVRClient*) handle->CALLER_ADDRESS;
const CPVRChannel *channel = CPVRManager::GetChannelGroups()->GetByClientFromAll(timer->channelNum, client->GetClientID());
if (channel == NULL)
{
CLog::Log(LOGERROR, "PVR: PVRTransferTimerEntry is called with not present channel");
return;
}
CPVRTimerInfoTag tag;
tag.SetClientID(client->GetClientID());
tag.SetClientIndex(timer->index);
tag.SetActive(timer->active == 1);
tag.SetTitle(timer->title);
tag.SetDir(timer->directory);
tag.SetClientNumber(timer->channelNum);
tag.SetStart((time_t) (timer->starttime+client->GetTimeCorrection()));
tag.SetStop((time_t) (timer->endtime+client->GetTimeCorrection()));
tag.SetFirstDay((time_t) (timer->firstday+client->GetTimeCorrection()));
tag.SetPriority(timer->priority);
tag.SetLifetime(timer->lifetime);
tag.SetRecording(timer->recording == 1);
tag.SetRepeating(timer->repeat == 1);
tag.SetWeekdays(timer->repeatflags);
CStdString path;
path.Format("pvr://client%i/timers/%i", tag.ClientID(), tag.ClientIndex());
tag.SetPath(path);
xbmcTimers->Update(tag);
return;
}
void CAddonCallbacksPVR::PVRConnectionStateChange(void* addonData, const char* strConnectionString, PVR_CONNECTION_STATE newState, const char *strMessage)
{
CPVRClient *client = GetPVRClient(addonData);
if (!client || !strConnectionString)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
const PVR_CONNECTION_STATE prevState(client->GetConnectionState());
if (prevState == newState)
return;
CLog::Log(LOGDEBUG, "PVR - %s - state for connection '%s' on client '%s' changed from '%d' to '%d'", __FUNCTION__, strConnectionString, client->Name().c_str(), prevState, newState);
client->SetConnectionState(newState);
std::string msg;
if (strMessage != nullptr)
msg = strMessage;
g_PVRManager.ConnectionStateChange(client->GetID(), std::string(strConnectionString), newState, msg);
}
void CAddonCallbacksPVR::PVRTransferTimerEntry(void *addonData, const ADDON_HANDLE handle, const PVR_TIMER *timer)
{
if (!handle)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
CPVRClient *client = GetPVRClient(addonData);
CPVRTimers *xbmcTimers = static_cast<CPVRTimers *>(handle->dataAddress);
if (!timer || !client || !xbmcTimers)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
/* Note: channel can be NULL here, for instance for epg-based timer rules ("record on any channel" condition). */
CPVRChannelPtr channel = g_PVRChannelGroups->GetByUniqueID(timer->iClientChannelUid, client->GetID());
/* transfer this entry to the timers container */
CPVRTimerInfoTagPtr transferTimer(new CPVRTimerInfoTag(*timer, channel, client->GetID()));
xbmcTimers->UpdateFromClient(transferTimer);
}
void CAddonCallbacksPVR::PVRTriggerEpgUpdate(void *addonData, unsigned int iChannelUid)
{
// get the client
CPVRClient *client = GetPVRClient(addonData);
if (!client)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
// get the channel
CPVRChannelPtr channel = g_PVRChannelGroups->GetByUniqueID(iChannelUid, client->GetID());
CEpg* epg(NULL);
// get the EPG for the channel
if (!channel || (epg = channel->GetEPG()) == NULL)
{
CLog::Log(LOGERROR, "PVR - %s - invalid channel or channel doesn't have an EPG", __FUNCTION__);
return;
}
// force an update
epg->ForceUpdate();
}
void CAddonCallbacksPVR::PVRTransferChannelGroupMember(void *addonData, const PVR_HANDLE handle, const PVR_CHANNEL_GROUP_MEMBER *member)
{
CAddonCallbacks* addon = (CAddonCallbacks*) addonData;
if (addon == NULL || handle == NULL || member == NULL || handle->dataAddress == NULL)
{
CLog::Log(LOGERROR, "CAddonCallbacksPVR - %s - called with a null pointer", __FUNCTION__);
return;
}
CPVRClient* client = (CPVRClient*) handle->callerAddress;
CPVRChannelGroup *group = (CPVRChannelGroup *) handle->dataAddress;
CPVRChannel *channel = (CPVRChannel *) g_PVRChannelGroups->GetByUniqueID(member->iChannelUniqueId, client->GetClientID());
if (group != NULL && channel != NULL && group->IsRadio() == channel->IsRadio())
{
/* transfer this entry to the group */
group->AddToGroup(*channel, member->iChannelNumber, false);
}
else
{
CLog::Log(LOGERROR, "CAddonCallbacksPVR - %s - cannot find group '%s' or channel '%d'",
__FUNCTION__, member->strGroupName, member->iChannelUniqueId);
}
}
void CAddonCallbacksPVR::PVRConnectionStateChange(void* addonData, const char* strConnectionString, PVR_CONNECTION_STATE newState, const char *strMessage)
{
CPVRClient *client = GetPVRClient(addonData);
if (!client || !strConnectionString)
{
CLog::Log(LOGERROR, "PVR - %s - invalid handler data", __FUNCTION__);
return;
}
const PVR_CONNECTION_STATE prevState(client->GetConnectionState());
if (prevState == newState)
return;
CLog::Log(LOGDEBUG, "PVR - %s - state for connection '%s' on client '%s' changed from '%d' to '%d'", __FUNCTION__, strConnectionString, client->Name().c_str(), prevState, newState);
client->SetConnectionState(newState);
int iMsg(-1);
bool bError(true);
bool bNotify(true);
switch (newState)
{
case PVR_CONNECTION_STATE_SERVER_UNREACHABLE:
iMsg = 35505; // Server is unreachable
break;
case PVR_CONNECTION_STATE_SERVER_MISMATCH:
iMsg = 35506; // Server does not respond properly
break;
case PVR_CONNECTION_STATE_VERSION_MISMATCH:
iMsg = 35507; // Server version is not compatible
break;
case PVR_CONNECTION_STATE_ACCESS_DENIED:
iMsg = 35508; // Access denied
break;
case PVR_CONNECTION_STATE_CONNECTED:
iMsg = 36034; // Connection established
bError = false;
// No notification for the first successful connect.
bNotify = (prevState != PVR_CONNECTION_STATE_UNKNOWN);
break;
case PVR_CONNECTION_STATE_DISCONNECTED:
iMsg = 36030; // Connection lost
break;
default:
CLog::Log(LOGERROR, "PVR - %s - unknown connection state", __FUNCTION__);
return;
}
// Use addon-supplied message, if present
std::string strMsg;
if (strMessage && strlen(strMessage) > 0)
strMsg = strMessage;
else
strMsg = g_localizeStrings.Get(iMsg);
// Notify user.
if (bNotify && !CSettings::GetInstance().GetBool(CSettings::SETTING_PVRMANAGER_HIDECONNECTIONLOSTWARNING))
CGUIDialogKaiToast::QueueNotification(
bError ? CGUIDialogKaiToast::Error : CGUIDialogKaiToast::Info, client->Name().c_str(), strMsg, 5000, true);
// Write event log entry.
CEventLog::GetInstance().Add(EventPtr(new CNotificationEvent(
client->Name(), strMsg, client->Icon(), bError ? EventLevel::Error : EventLevel::Information)));
}
