mirror of
https://github.com/DSheirer/sdrtrunk.git
synced 2026-11-12 08:37:25 -05:00
641 lines
24 KiB
Java
641 lines
24 KiB
Java
/*
|
|
* *****************************************************************************
|
|
* Copyright (C) 2014-2024 Dennis Sheirer
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
* ****************************************************************************
|
|
*/
|
|
package io.github.dsheirer.channel.state;
|
|
|
|
import com.google.common.eventbus.Subscribe;
|
|
import io.github.dsheirer.alias.AliasModel;
|
|
import io.github.dsheirer.audio.squelch.SquelchStateEvent;
|
|
import io.github.dsheirer.channel.metadata.ChannelMetadata;
|
|
import io.github.dsheirer.channel.state.DecoderStateEvent.Event;
|
|
import io.github.dsheirer.controller.channel.Channel;
|
|
import io.github.dsheirer.controller.channel.ChannelConfigurationChangeNotification;
|
|
import io.github.dsheirer.controller.channel.ChannelEvent;
|
|
import io.github.dsheirer.identifier.IdentifierClass;
|
|
import io.github.dsheirer.identifier.IdentifierUpdateListener;
|
|
import io.github.dsheirer.identifier.IdentifierUpdateNotification;
|
|
import io.github.dsheirer.identifier.MutableIdentifierCollection;
|
|
import io.github.dsheirer.identifier.configuration.AliasListConfigurationIdentifier;
|
|
import io.github.dsheirer.identifier.configuration.ChannelNameConfigurationIdentifier;
|
|
import io.github.dsheirer.identifier.configuration.DecoderTypeConfigurationIdentifier;
|
|
import io.github.dsheirer.identifier.configuration.FrequencyConfigurationIdentifier;
|
|
import io.github.dsheirer.identifier.configuration.SiteConfigurationIdentifier;
|
|
import io.github.dsheirer.identifier.configuration.SystemConfigurationIdentifier;
|
|
import io.github.dsheirer.identifier.decoder.ChannelStateIdentifier;
|
|
import io.github.dsheirer.module.decode.event.IDecodeEvent;
|
|
import io.github.dsheirer.sample.Listener;
|
|
import io.github.dsheirer.source.ISourceEventListener;
|
|
import io.github.dsheirer.source.SourceEvent;
|
|
import io.github.dsheirer.source.SourceType;
|
|
import io.github.dsheirer.source.config.SourceConfigTuner;
|
|
import io.github.dsheirer.source.config.SourceConfigTunerMultipleFrequency;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.TreeMap;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
/**
|
|
* Multi-Channel state tracks the overall state of all processing modules and decoders configured for the channel
|
|
* and provides squelch control and decoder state reset events.
|
|
*
|
|
* Uses a state enumeration that defines allowable channel state transitions in order to track a call or data decode
|
|
* event from start to finish. Uses a timer to monitor for inactivity and to provide a FADE period that indicates
|
|
* to the user that the activity has stopped while continuing to provide details about the call, before the state is
|
|
* reset to IDLE.
|
|
*
|
|
* State Descriptions:
|
|
* IDLE: Normal state. No voice or data call activity
|
|
* CALL/DATA/ENCRYPTED/CONTROL: Decoding states.
|
|
* FADE: The phase after a voice or data call when either an explicit call end has been received, or when no new
|
|
* signalling updates have been received, and the fade timer has expired. This phase allows for gui updates to
|
|
* signal to the user that the call is ended, while continuing to display the call details for the user
|
|
* TEARDOWN: Indicates a traffic channel that will be torn down for reuse.
|
|
*/
|
|
public class MultiChannelState extends AbstractChannelState implements IDecoderStateEventListener, ISourceEventListener,
|
|
IdentifierUpdateListener, IStateMachineListener
|
|
{
|
|
private final static Logger mLog = LoggerFactory.getLogger(MultiChannelState.class);
|
|
|
|
public static final long FADE_TIMEOUT_DELAY = 1200;
|
|
public static final long RESET_TIMEOUT_DELAY = 2000;
|
|
|
|
private IdentifierUpdateNotificationProxy mIdentifierUpdateNotificationProxy = new IdentifierUpdateNotificationProxy();
|
|
private DecoderStateEventReceiver mDecoderStateEventReceiver = new DecoderStateEventReceiver();
|
|
private SourceEventListener mInternalSourceEventListener;
|
|
private Map<Integer,ChannelMetadata> mChannelMetadataMap = new TreeMap<>();
|
|
private Map<Integer,MutableIdentifierCollection> mIdentifierCollectionMap = new TreeMap<>();
|
|
private Map<Integer,StateMachine> mStateMachineMap = new TreeMap<>();
|
|
private Map<Integer,StateMonitoringSquelchController> mSquelchControllerMap = new TreeMap<>();
|
|
private int[] mTimeslots;
|
|
private DecoderStateNotificationEventCache mStateNotificationCache = new DecoderStateNotificationEventCache();
|
|
private Listener<IdentifierUpdateNotification> mIdentifierUpdateListener = new IdentifierUpdateListenerProxy();
|
|
|
|
/**
|
|
* Constructs an instance
|
|
* @param channel configuration
|
|
* @param aliasModel for channel metadata and identifiers
|
|
* @param timeslots array of timeslot numbers to use
|
|
*/
|
|
public MultiChannelState(Channel channel, AliasModel aliasModel, int[] timeslots)
|
|
{
|
|
super(channel);
|
|
|
|
mTimeslots = timeslots;
|
|
|
|
for(int timeslot: timeslots)
|
|
{
|
|
mChannelMetadataMap.put(timeslot, new ChannelMetadata(aliasModel, timeslot));
|
|
MutableIdentifierCollection mutableIdentifierCollection = new MutableIdentifierCollection(timeslot);
|
|
mIdentifierCollectionMap.put(timeslot, mutableIdentifierCollection);
|
|
|
|
//Set the proxy as a listener so that echo'd updates are broadcast externally
|
|
mutableIdentifierCollection.setIdentifierUpdateListener(mIdentifierUpdateNotificationProxy);
|
|
|
|
StateMachine stateMachine = new StateMachine(timeslot, State.MULTI_CHANNEL_ACTIVE_STATES);
|
|
mStateMachineMap.put(timeslot, stateMachine);
|
|
stateMachine.addListener(this);
|
|
|
|
StateMonitoringSquelchController squelchController = new StateMonitoringSquelchController(timeslot);
|
|
mSquelchControllerMap.put(timeslot, squelchController);
|
|
stateMachine.addListener(squelchController);
|
|
|
|
stateMachine.setIdentifierUpdateListener(mutableIdentifierCollection);
|
|
stateMachine.setEndTimeoutBufferMilliseconds(RESET_TIMEOUT_DELAY);
|
|
stateMachine.setFadeTimeoutBufferMilliseconds(FADE_TIMEOUT_DELAY);
|
|
}
|
|
|
|
configureChannelType(channel);
|
|
|
|
createConfigurationIdentifiers(channel);
|
|
}
|
|
|
|
/**
|
|
* Configure items according to channel type
|
|
* @param channel configuration
|
|
*/
|
|
private void configureChannelType(Channel channel)
|
|
{
|
|
for(int timeslot: mTimeslots)
|
|
{
|
|
StateMachine stateMachine = mStateMachineMap.get(timeslot);
|
|
stateMachine.setChannelType(channel.getChannelType());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Receive notification that the underlying channel configuration has changed.
|
|
* @param notification
|
|
*/
|
|
@Subscribe
|
|
public void channelConfigurationChanged(ChannelConfigurationChangeNotification notification)
|
|
{
|
|
updateChannelConfiguration(notification.getChannel());
|
|
configureChannelType(notification.getChannel());
|
|
createConfigurationIdentifiers(notification.getChannel());
|
|
}
|
|
|
|
@Override
|
|
public void stateChanged(State state, int timeslot)
|
|
{
|
|
ChannelStateIdentifier stateIdentifier = ChannelStateIdentifier.get(state);
|
|
mIdentifierCollectionMap.get(timeslot).update(stateIdentifier);
|
|
mChannelMetadataMap.get(timeslot).receive(new IdentifierUpdateNotification(stateIdentifier, IdentifierUpdateNotification.Operation.ADD, timeslot));
|
|
|
|
switch(state)
|
|
{
|
|
case RESET:
|
|
reset(timeslot);
|
|
mStateMachineMap.get(timeslot).setState(State.IDLE);
|
|
break;
|
|
case TEARDOWN:
|
|
mTeardownSequenceStarted = true;
|
|
if(getChannel().isTrafficChannel())
|
|
{
|
|
checkTeardown();
|
|
}
|
|
else
|
|
{
|
|
mStateMachineMap.get(timeslot).setState(State.RESET);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks the state of each timeslot and issues a teardown request if all timeslots are inactive
|
|
*/
|
|
private void checkTeardown()
|
|
{
|
|
boolean teardown = false;
|
|
boolean active = false;
|
|
|
|
for(StateMachine stateMachine: mStateMachineMap.values())
|
|
{
|
|
State state = stateMachine.getState();
|
|
|
|
//If we have an active state in either timeslot, don't teardown. IDLE is a special state that is active
|
|
//but doesn't prevent a teardown when the other timeslot is in TEARDOWN
|
|
if(State.MULTI_CHANNEL_ACTIVE_STATES.contains(state) && state != State.IDLE)
|
|
{
|
|
active = true;
|
|
}
|
|
else if(state == State.TEARDOWN)
|
|
{
|
|
teardown = true;
|
|
}
|
|
}
|
|
|
|
if(teardown && !active)
|
|
{
|
|
if(getChannel().isTrafficChannel())
|
|
{
|
|
try
|
|
{
|
|
broadcast(new ChannelEvent(getChannel(), ChannelEvent.Event.REQUEST_DISABLE));
|
|
}
|
|
catch(Throwable t)
|
|
{
|
|
mLog.error("Error broadcasting shutdown channel event", t);
|
|
}
|
|
|
|
mTeardownSequenceStarted = true;
|
|
}
|
|
else
|
|
{
|
|
for(StateMachine stateMachine: mStateMachineMap.values())
|
|
{
|
|
stateMachine.setState(State.RESET);
|
|
}
|
|
}
|
|
}
|
|
//If one timeslot is teardown but the other is still active, reset the teardown timeslot to IDLE
|
|
else if(teardown && active)
|
|
{
|
|
for(StateMachine stateMachine: mStateMachineMap.values())
|
|
{
|
|
if(stateMachine.getState() == State.TEARDOWN)
|
|
{
|
|
stateMachine.setState(State.RESET);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void checkState()
|
|
{
|
|
for(StateMachine stateMachine: mStateMachineMap.values())
|
|
{
|
|
stateMachine.checkState();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isTeardownState()
|
|
{
|
|
for(StateMachine stateMachine: mStateMachineMap.values())
|
|
{
|
|
if(stateMachine.getState() == State.TEARDOWN)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Creates configuration identifiers for the channel name, system, site and alias list name.
|
|
*/
|
|
private void createConfigurationIdentifiers(Channel channel)
|
|
{
|
|
for(int timeslot: mTimeslots)
|
|
{
|
|
MutableIdentifierCollection identifierCollection = mIdentifierCollectionMap.get(timeslot);
|
|
|
|
identifierCollection.update(DecoderTypeConfigurationIdentifier.create(channel.getDecodeConfiguration().getDecoderType()));
|
|
|
|
if(channel.hasSystem())
|
|
{
|
|
identifierCollection.update(SystemConfigurationIdentifier.create(channel.getSystem()));
|
|
}
|
|
if(channel.hasSite())
|
|
{
|
|
identifierCollection.update(SiteConfigurationIdentifier.create(channel.getSite()));
|
|
}
|
|
if(channel.getName() != null && !channel.getName().isEmpty())
|
|
{
|
|
identifierCollection.update(ChannelNameConfigurationIdentifier.create(channel.getName()));
|
|
}
|
|
if(channel.getAliasListName() != null && !channel.getAliasListName().isEmpty())
|
|
{
|
|
identifierCollection.update(AliasListConfigurationIdentifier.create(channel.getAliasListName()));
|
|
}
|
|
if(channel.getSourceConfiguration().getSourceType() == SourceType.TUNER)
|
|
{
|
|
long frequency = ((SourceConfigTuner)channel.getSourceConfiguration()).getFrequency();
|
|
identifierCollection.update(FrequencyConfigurationIdentifier.create(frequency));
|
|
}
|
|
else if(channel.getSourceConfiguration().getSourceType() == SourceType.TUNER_MULTIPLE_FREQUENCIES)
|
|
{
|
|
List<Long> frequencies = ((SourceConfigTunerMultipleFrequency)channel.getSourceConfiguration()).getFrequencies();
|
|
|
|
if(frequencies.size() > 0)
|
|
{
|
|
identifierCollection.update(FrequencyConfigurationIdentifier.create(frequencies.get(0)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Interface to receive channel identifier updates from this channel state and from any
|
|
* decoder states.
|
|
*/
|
|
@Override
|
|
public Listener<IdentifierUpdateNotification> getIdentifierUpdateListener()
|
|
{
|
|
return mIdentifierUpdateListener;
|
|
}
|
|
|
|
/**
|
|
* Registers the external listener that will receive identifier update notifications produced by this channel state
|
|
* @param listener
|
|
*/
|
|
@Override
|
|
public void setIdentifierUpdateListener(Listener<IdentifierUpdateNotification> listener)
|
|
{
|
|
mIdentifierUpdateNotificationProxy.setListener(listener);
|
|
}
|
|
|
|
/**
|
|
* Unregisters the external listener from receiving identifier update notifications produced by this channel state
|
|
*/
|
|
@Override
|
|
public void removeIdentifierUpdateListener()
|
|
{
|
|
mIdentifierUpdateNotificationProxy.setListener(null);
|
|
}
|
|
|
|
/**
|
|
* Updates the channel state identifier collection using the update notification. This update will be reflected
|
|
* in the internal channel state and will also be broadcast to any listeners, including the channel metadata for
|
|
* this channel state.
|
|
*/
|
|
@Override
|
|
public void updateChannelStateIdentifiers(IdentifierUpdateNotification notification)
|
|
{
|
|
//Explicitly add or remove the identifier from the local identifier collection to allow it to be rebroadcast
|
|
//to external listeners, which includes this state's channel metadata
|
|
MutableIdentifierCollection identifierCollection = mIdentifierCollectionMap.get(notification.getTimeslot());
|
|
|
|
if(identifierCollection != null)
|
|
{
|
|
if(notification.isAdd())
|
|
{
|
|
identifierCollection.update(notification.getIdentifier());
|
|
}
|
|
else if(notification.isSilentAdd())
|
|
{
|
|
identifierCollection.silentUpdate(notification.getIdentifier());
|
|
}
|
|
else if(notification.isRemove())
|
|
{
|
|
identifierCollection.remove(notification.getIdentifier());
|
|
}
|
|
else if(notification.isSilentRemove())
|
|
{
|
|
identifierCollection.silentRemove(notification.getIdentifier());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Channel metadata for this channel.
|
|
*/
|
|
public List<ChannelMetadata> getChannelMetadata()
|
|
{
|
|
return new ArrayList<>(mChannelMetadataMap.values());
|
|
}
|
|
|
|
/**
|
|
* Resets this channel state and prepares it for reuse.
|
|
*/
|
|
@Override
|
|
public void reset()
|
|
{
|
|
for(int timeslot: mTimeslots)
|
|
{
|
|
reset(timeslot);
|
|
}
|
|
|
|
sourceOverflow(false);
|
|
}
|
|
|
|
private void reset(int timeslot)
|
|
{
|
|
mStateMachineMap.get(timeslot).setState(State.RESET);
|
|
broadcast(new DecoderStateEvent(this, Event.REQUEST_RESET, State.IDLE, timeslot));
|
|
MutableIdentifierCollection identifierCollection = mIdentifierCollectionMap.get(timeslot);
|
|
identifierCollection.remove(IdentifierClass.USER);
|
|
}
|
|
|
|
@Override
|
|
public void start()
|
|
{
|
|
for(int timeslot: mTimeslots)
|
|
{
|
|
mIdentifierCollectionMap.get(timeslot).broadcastIdentifiers();
|
|
mStateMachineMap.get(timeslot).setState(State.RESET);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void stop()
|
|
{
|
|
for(StateMonitoringSquelchController squelchController: mSquelchControllerMap.values())
|
|
{
|
|
squelchController.setSquelchLock(false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Listener<SourceEvent> getSourceEventListener()
|
|
{
|
|
if(mInternalSourceEventListener == null)
|
|
{
|
|
mInternalSourceEventListener = new SourceEventListener();
|
|
}
|
|
|
|
return mInternalSourceEventListener;
|
|
}
|
|
|
|
|
|
@Override
|
|
public void setSquelchStateListener(Listener<SquelchStateEvent> listener)
|
|
{
|
|
for(StateMonitoringSquelchController squelchController: mSquelchControllerMap.values())
|
|
{
|
|
squelchController.setSquelchStateListener(listener);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void removeSquelchStateListener()
|
|
{
|
|
for(StateMonitoringSquelchController squelchController: mSquelchControllerMap.values())
|
|
{
|
|
squelchController.removeSquelchStateListener();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Broadcasts the source event to a registered external source event listener
|
|
*/
|
|
protected void broadcast(SourceEvent sourceEvent)
|
|
{
|
|
if(mExternalSourceEventListener != null)
|
|
{
|
|
mExternalSourceEventListener.receive(sourceEvent);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Broadcasts the call event to the registered listener
|
|
*/
|
|
protected void broadcast(IDecodeEvent event)
|
|
{
|
|
if(mDecodeEventListener != null)
|
|
{
|
|
mDecodeEventListener.receive(event);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Broadcasts the channel event to a registered listener
|
|
*/
|
|
private void broadcast(ChannelEvent channelEvent)
|
|
{
|
|
if(mChannelEventListener != null)
|
|
{
|
|
mChannelEventListener.receive(channelEvent);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Broadcasts a channel state event to any registered listeners
|
|
*/
|
|
protected void broadcast(DecoderStateEvent event)
|
|
{
|
|
if(mDecoderStateListener != null)
|
|
{
|
|
mDecoderStateListener.receive(event);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Listener<DecoderStateEvent> getDecoderStateListener()
|
|
{
|
|
return mDecoderStateEventReceiver;
|
|
}
|
|
|
|
/**
|
|
* Listener to receive source events.
|
|
*/
|
|
public class SourceEventListener implements Listener<SourceEvent>
|
|
{
|
|
@Override
|
|
public void receive(SourceEvent sourceEvent)
|
|
{
|
|
switch(sourceEvent.getEvent())
|
|
{
|
|
case NOTIFICATION_FREQUENCY_CHANGE:
|
|
//Rebroadcast source frequency change events for the decoder(s) to process
|
|
long frequency = sourceEvent.getValue().longValue();
|
|
|
|
for(int timeslot: mTimeslots)
|
|
{
|
|
broadcast(new DecoderStateEvent(this, Event.NOTIFICATION_SOURCE_FREQUENCY,
|
|
mStateMachineMap.get(timeslot).getState(), frequency));
|
|
|
|
//Create a new frequency configuration identifier so that downstream consumers receive the change
|
|
//via channel metadata and audio packet updates - this is a silent add that is sent as a notification
|
|
//to all identifier collections so that they don't rebroadcast the change and cause a feedback loop
|
|
|
|
mIdentifierUpdateNotificationProxy.receive(new IdentifierUpdateNotification(
|
|
FrequencyConfigurationIdentifier.create(frequency), IdentifierUpdateNotification.Operation.SILENT_ADD, timeslot));
|
|
}
|
|
|
|
break;
|
|
case NOTIFICATION_MEASURED_FREQUENCY_ERROR:
|
|
//Rebroadcast frequency error measurements to external listener if we're currently
|
|
//in an active (ie sync locked) state.
|
|
for(int timeslot: mTimeslots)
|
|
{
|
|
if(State.MULTI_CHANNEL_ACTIVE_STATES.contains(mStateMachineMap.get(timeslot).getState()))
|
|
{
|
|
broadcast(SourceEvent.frequencyErrorMeasurementSyncLocked(sourceEvent.getValue().longValue(),
|
|
getChannel().getChannelType().name()));
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* DecoderStateEvent receiver wrapper
|
|
*/
|
|
public class DecoderStateEventReceiver implements Listener<DecoderStateEvent>
|
|
{
|
|
@Override
|
|
public void receive(DecoderStateEvent event)
|
|
{
|
|
if(event.getSource() != this)
|
|
{
|
|
switch(event.getEvent())
|
|
{
|
|
case REQUEST_ALWAYS_UNSQUELCH:
|
|
mSquelchControllerMap.get(event.getTimeslot()).setSquelchLock(true);
|
|
break;
|
|
case REQUEST_CHANGE_CALL_TIMEOUT:
|
|
if(event instanceof ChangeChannelTimeoutEvent)
|
|
{
|
|
ChangeChannelTimeoutEvent timeout = (ChangeChannelTimeoutEvent)event;
|
|
mStateMachineMap.get(event.getTimeslot()).setFadeTimeoutBufferMilliseconds(timeout.getCallTimeoutMilliseconds());
|
|
}
|
|
break;
|
|
case CONTINUATION:
|
|
case DECODE:
|
|
case START:
|
|
if(State.MULTI_CHANNEL_ACTIVE_STATES.contains(event.getState()))
|
|
{
|
|
mStateMachineMap.get(event.getTimeslot()).setState(event.getState());
|
|
|
|
//Broadcast current channel/timeslot state so that channel rotation monitor can track
|
|
broadcast(mStateNotificationCache.getStateNotificationEvent(event.getState(), event.getTimeslot()));
|
|
}
|
|
break;
|
|
case END:
|
|
mStateMachineMap.get(event.getTimeslot()).setState(event.getState());
|
|
|
|
//Broadcast current channel/timeslot state so that channel rotation monitor can track
|
|
broadcast(mStateNotificationCache.getStateNotificationEvent(event.getState(), event.getTimeslot()));
|
|
break;
|
|
case REQUEST_RESET:
|
|
/* Channel State does not respond to reset events */
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Receives and passes identifier update notifications to the correct channel metadata collections
|
|
*/
|
|
public class IdentifierUpdateListenerProxy implements Listener<IdentifierUpdateNotification>
|
|
{
|
|
@Override
|
|
public void receive(IdentifierUpdateNotification identifierUpdateNotification)
|
|
{
|
|
int timeslot = identifierUpdateNotification.getTimeslot();
|
|
|
|
ChannelMetadata channelMetadata = mChannelMetadataMap.get(timeslot);
|
|
|
|
if(channelMetadata != null)
|
|
{
|
|
channelMetadata.receive(identifierUpdateNotification);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Proxy between the internal identifier collections and the external update notification listener. This proxy
|
|
* enables access to internal components to broadcast silent identifier update notifications externally.
|
|
*/
|
|
public class IdentifierUpdateNotificationProxy implements Listener<IdentifierUpdateNotification>
|
|
{
|
|
private Listener<IdentifierUpdateNotification> mIdentifierUpdateNotificationListener;
|
|
|
|
@Override
|
|
public void receive(IdentifierUpdateNotification identifierUpdateNotification)
|
|
{
|
|
if(mIdentifierUpdateNotificationListener != null)
|
|
{
|
|
mIdentifierUpdateNotificationListener.receive(identifierUpdateNotification);
|
|
}
|
|
}
|
|
|
|
public void setListener(Listener<IdentifierUpdateNotification> listener)
|
|
{
|
|
mIdentifierUpdateNotificationListener = listener;
|
|
}
|
|
|
|
public void removeListener()
|
|
{
|
|
mIdentifierUpdateNotificationListener = null;
|
|
}
|
|
}
|
|
|
|
}
|