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 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);
}
}
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::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);
}
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()));
}
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::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::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)));
}