Compare commits

..

1 Commits

Author SHA1 Message Date
Wahaj18
08753eedcd Show the identifier of auto-added talker alias radios (#2743)
Radio and P25FullyQualifiedRadio didn't set the value property when built
with the value constructor, which is how TalkerAliasAutoAdder creates the
radio ID for a new alias. The Identifier column in the alias view by
identifier type binds to that property, so it stayed blank until the alias
was edited or the playlist was reloaded through the setters.

Fixes #2730
2026-11-21 07:08:46 -05:00
78 changed files with 253 additions and 11432 deletions

View File

@@ -151,8 +151,6 @@ dependencies {
} }
implementation 'com.google.code.gson:gson:2.15.0' implementation 'com.google.code.gson:gson:2.15.0'
implementation 'com.google.guava:guava:33.8.0-jre' implementation 'com.google.guava:guava:33.8.0-jre'
implementation 'com.h2database:h2:2.5.252' //Built-in call database
implementation 'com.zaxxer:HikariCP:7.1.0' //Database connection pool
implementation 'com.mpatric:mp3agic:0.9.1' implementation 'com.mpatric:mp3agic:0.9.1'
implementation 'commons-io:commons-io:2.22.0' implementation 'commons-io:commons-io:2.22.0'
implementation 'io.github.dsheirer:jairspy:1.0.12.1' //Airspy tuners - GitHub release, see settings.gradle implementation 'io.github.dsheirer:jairspy:1.0.12.1' //Airspy tuners - GitHub release, see settings.gradle
@@ -173,8 +171,6 @@ dependencies {
implementation 'org.apache.mina:mina-core:2.2.10' implementation 'org.apache.mina:mina-core:2.2.10'
implementation 'org.apache.mina:mina-http:2.2.10' implementation 'org.apache.mina:mina-http:2.2.10'
implementation 'org.controlsfx:controlsfx:11.2.6' implementation 'org.controlsfx:controlsfx:11.2.6'
implementation 'org.mariadb.jdbc:mariadb-java-client:3.5.11' //Optional MariaDB call database
implementation 'org.postgresql:postgresql:42.7.14' //Optional PostgreSQL call database
implementation 'org.rauschig:jarchivelib:1.2.0' implementation 'org.rauschig:jarchivelib:1.2.0'
implementation 'org.slf4j:slf4j-api:2.0.20' implementation 'org.slf4j:slf4j-api:2.0.20'
} }
@@ -313,11 +309,9 @@ def configure(RuntimeZipTask rt, List<String> jvmArgs) {
//jdk.incubator.vector - needed for Project Panama foreign function and vector apis //jdk.incubator.vector - needed for Project Panama foreign function and vector apis
//jdk.accessibility is used with assistive technologies like screen readers //jdk.accessibility is used with assistive technologies like screen readers
//java.management for JVM resource monitoring //java.management for JVM resource monitoring
//java.sql, java.naming, java.security.jgss, jdk.net - call database JDBC drivers and connection pool
//java.base, java.desktop, java.logging, java.net.http, java.prefs, javafx.controls - required by sdrtrunk (jdeps) //java.base, java.desktop, java.logging, java.net.http, java.prefs, javafx.controls - required by sdrtrunk (jdeps)
rt.extension.addModules('jdk.charsets', 'jdk.crypto.ec', 'jdk.incubator.vector', 'jdk.accessibility', 'java.management', rt.extension.addModules('jdk.charsets', 'jdk.crypto.ec', 'jdk.incubator.vector', 'jdk.accessibility', 'java.management',
'java.base', 'java.desktop', 'java.logging', 'java.net.http', 'java.prefs', 'javafx.controls', 'java.sql', 'java.base', 'java.desktop', 'java.logging', 'java.net.http', 'java.prefs', 'javafx.controls')
'java.naming', 'java.security.jgss', 'jdk.net')
//Use only the modules listed above. The runtime plugin's module auto-detection uses a bundled ASM library that //Use only the modules listed above. The runtime plugin's module auto-detection uses a bundled ASM library that
//can't read Java 27 class files and logs a 'Failed to scan' error for each sdrtrunk class. The jdeps module check //can't read Java 27 class files and logs a 'Failed to scan' error for each sdrtrunk class. The jdeps module check

View File

@@ -530,34 +530,6 @@ public class AliasList
return Collections.emptyList(); return Collections.emptyList();
} }
/**
* Alias for a talkgroup that is identified by its stored values instead of an identifier instance, for example a
* talkgroup from the call database.
* @param protocol of the talkgroup
* @param value of the talkgroup
* @param fullyQualifiedAddress (wacn.system.id) of a fully qualified talkgroup, or null
* @return alias or null
*/
public Alias getTalkgroupAlias(Protocol protocol, int value, String fullyQualifiedAddress)
{
TalkgroupAliasList talkgroupAliasList = protocol != null ? mTalkgroupProtocolMap.get(protocol) : null;
return talkgroupAliasList != null ? talkgroupAliasList.getAlias(value, fullyQualifiedAddress) : null;
}
/**
* Alias for a radio that is identified by its stored values instead of an identifier instance, for example a
* radio from the call database.
* @param protocol of the radio
* @param value of the radio
* @param fullyQualifiedAddress (wacn.system.id) of a fully qualified radio, or null
* @return alias or null
*/
public Alias getRadioAlias(Protocol protocol, int value, String fullyQualifiedAddress)
{
RadioAliasList radioAliasList = protocol != null ? mRadioProtocolMap.get(protocol) : null;
return radioAliasList != null ? radioAliasList.getAlias(value, fullyQualifiedAddress) : null;
}
private static List<Alias> toList(Alias alias) private static List<Alias> toList(Alias alias)
{ {
if(alias != null) if(alias != null)
@@ -698,26 +670,11 @@ public class AliasList
//Attempt to do a fully qualified identifier match only //Attempt to do a fully qualified identifier match only
if(identifier instanceof FullyQualifiedTalkgroupIdentifier fqti) if(identifier instanceof FullyQualifiedTalkgroupIdentifier fqti)
{ {
return getAlias(fqti.getValue(), fqti.getFullyQualifiedTalkgroupAddress()); return mFullyQualifiedTalkgroupAliasMap.get(fqti.getFullyQualifiedTalkgroupAddress());
}
return getAlias(identifier.getValue(), null);
}
/**
* Alias for a talkgroup value, or for a fully qualified talkgroup address.
* @param value of the talkgroup
* @param fullyQualifiedAddress (wacn.system.id) for a fully qualified talkgroup, which is matched exclusively,
* or null.
*/
public Alias getAlias(int value, String fullyQualifiedAddress)
{
if(fullyQualifiedAddress != null)
{
return mFullyQualifiedTalkgroupAliasMap.get(fullyQualifiedAddress);
} }
//Attempt to match the talkgroup value //Attempt to match the talkgroup value
int value = identifier.getValue();
Alias mapValue = mTalkgroupAliasMap.get(value); Alias mapValue = mTalkgroupAliasMap.get(value);
if (mapValue != null) if (mapValue != null)
@@ -833,26 +790,11 @@ public class AliasList
//Match fully qualified identifier only. //Match fully qualified identifier only.
if(identifier instanceof FullyQualifiedRadioIdentifier fqri) if(identifier instanceof FullyQualifiedRadioIdentifier fqri)
{ {
return getAlias(fqri.getValue(), fqri.getFullyQualifiedRadioAddress()); return mFullyQualifiedRadioAliasMap.get(fqri.getFullyQualifiedRadioAddress());
}
return getAlias(identifier.getValue(), null);
}
/**
* Alias for a radio value, or for a fully qualified radio address.
* @param value of the radio
* @param fullyQualifiedAddress (wacn.system.id) for a fully qualified radio, which is matched exclusively, or
* null.
*/
public Alias getAlias(int value, String fullyQualifiedAddress)
{
if(fullyQualifiedAddress != null)
{
return mFullyQualifiedRadioAliasMap.get(fullyQualifiedAddress);
} }
//Attempt to match against the radio identifier //Attempt to match against the radio identifier
int value = identifier.getValue();
Alias mapValue = mRadioAliasMap.get(value); Alias mapValue = mRadioAliasMap.get(value);
if(mapValue != null) if(mapValue != null)

View File

@@ -48,6 +48,7 @@ public class P25FullyQualifiedRadio extends Radio
super(Protocol.APCO25, id); super(Protocol.APCO25, id);
mWacn = wacn; mWacn = wacn;
mSystem = system; mSystem = system;
updateValueProperty();
} }
@Override @Override

View File

@@ -45,6 +45,7 @@ public class Radio extends AliasID implements Comparable<Radio>
{ {
mProtocol = protocol; mProtocol = protocol;
mValue = value; mValue = value;
updateValueProperty();
} }
@Override @Override

View File

@@ -31,8 +31,6 @@ public class AudioEvent
AUDIO_STOPPED, AUDIO_STOPPED,
AUDIO_CONTINUATION, AUDIO_CONTINUATION,
AUDIO_CONFIGURATION_CHANGE_STARTED, AUDIO_CONFIGURATION_CHANGE_STARTED,
AUDIO_CONFIGURATION_CHANGE_COMPLETE, AUDIO_CONFIGURATION_CHANGE_COMPLETE;
REPLAY_STARTED,
REPLAY_STOPPED;
} }
} }

View File

@@ -38,7 +38,6 @@ import java.util.List;
import java.util.Set; import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import javafx.beans.property.BooleanProperty; import javafx.beans.property.BooleanProperty;
import javafx.beans.property.IntegerProperty; import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleBooleanProperty; import javafx.beans.property.SimpleBooleanProperty;
@@ -68,8 +67,6 @@ import org.slf4j.LoggerFactory;
public class AudioSegment implements Listener<IdentifierUpdateNotification> public class AudioSegment implements Listener<IdentifierUpdateNotification>
{ {
private final static Logger mLog = LoggerFactory.getLogger(AudioSegment.class); private final static Logger mLog = LoggerFactory.getLogger(AudioSegment.class);
private static final AtomicLong ID_GENERATOR = new AtomicLong();
private final long mId = ID_GENERATOR.incrementAndGet();
private BooleanProperty mComplete = new SimpleBooleanProperty(false); private BooleanProperty mComplete = new SimpleBooleanProperty(false);
private BooleanProperty mDuplicate = new SimpleBooleanProperty(false); private BooleanProperty mDuplicate = new SimpleBooleanProperty(false);
private BooleanProperty mEncrypted = new SimpleBooleanProperty(false); private BooleanProperty mEncrypted = new SimpleBooleanProperty(false);
@@ -99,15 +96,6 @@ public class AudioSegment implements Listener<IdentifierUpdateNotification>
mIdentifierCollection.setTimeslot(timeslot); mIdentifierCollection.setTimeslot(timeslot);
} }
/**
* Unique identifier of this audio segment for the current application session. The call manager uses it as the
* call key, which links a call that is playing on an audio channel to the call in the Calls tab.
*/
public long getId()
{
return mId;
}
/** /**
* Timeslot for this audio segment * Timeslot for this audio segment
*/ */

View File

@@ -97,35 +97,17 @@ public class MP3AudioConverter implements IAudioConverter
audioPackets = mResampler.resample(audioPackets); audioPackets = mResampler.resample(audioPackets);
} }
for(float[] audioPacket: audioPackets) for(int x = 0; x < audioPackets.size(); x++)
{ {
encodePacket(audioPacket, converted); byte[] bytesToEncode = null;
}
int finalChunkSize = mEncoder.encodeFinish(mOutputFramesBuffer);
if(finalChunkSize > 0)
{
converted.add(Arrays.copyOf(mOutputFramesBuffer, finalChunkSize));
}
return converted;
}
/**
* Encodes the PCM audio packet (already resampled) and adds any encoded MP3 frames to the list.
*/
private void encodePacket(float[] audioPacket, List<byte[]> converted)
{
byte[] bytesToEncode;
if(mInputAudioFormat.getAudioFormat().getSampleSizeInBits() == 16) if(mInputAudioFormat.getAudioFormat().getSampleSizeInBits() == 16)
{ {
bytesToEncode = ConversionUtils.convertToSigned16BitSamples(audioPacket).array(); bytesToEncode = ConversionUtils.convertToSigned16BitSamples(audioPackets.get(x)).array();
} }
else else
{ {
bytesToEncode = ConversionUtils.convertToSigned32BitSamples(audioPacket).array(); bytesToEncode = ConversionUtils.convertToSigned32BitSamples(audioPackets.get(x)).array();
} }
int bytesToEncodePointer = 0; int bytesToEncodePointer = 0;
@@ -153,61 +135,6 @@ public class MP3AudioConverter implements IAudioConverter
} }
} }
/**
* Encodes a chunk of a continuing audio stream to MP3. Unlike {@link #convert(List)}, the encoder and resampler
* keep their state between invocations, so the chunks of a call are encoded as one continuous stream. Invoke
* {@link #finishStream()} after the last chunk. Note: audio normalization is not applied.
*
* @param audioPackets of PCM audio sampled at 8 kHz
* @return encoded MP3 frames, possibly empty
*/
public List<byte[]> encodeStream(List<float[]> audioPackets)
{
List<byte[]> converted = new ArrayList<>();
if(mResampler != null)
{
List<float[]> resampled = new ArrayList<>();
mResampler.setListener(resampled::add);
for(float[] audioPacket: audioPackets)
{
mResampler.resample(audioPacket);
}
mResampler.setListener(null);
audioPackets = resampled;
}
for(float[] audioPacket: audioPackets)
{
encodePacket(audioPacket, converted);
}
return converted;
}
/**
* Flushes the resampler and the encoder at the end of a stream encoded with {@link #encodeStream(List)}.
* @return final encoded MP3 frames
*/
public List<byte[]> finishStream()
{
List<byte[]> converted = new ArrayList<>();
if(mResampler != null)
{
List<float[]> resampled = new ArrayList<>();
mResampler.setListener(resampled::add);
mResampler.flush();
mResampler.setListener(null);
for(float[] audioPacket: resampled)
{
encodePacket(audioPacket, converted);
}
}
int finalChunkSize = mEncoder.encodeFinish(mOutputFramesBuffer); int finalChunkSize = mEncoder.encodeFinish(mOutputFramesBuffer);
if(finalChunkSize > 0) if(finalChunkSize > 0)

View File

@@ -61,17 +61,12 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
private final String mChannelName; private final String mChannelName;
private final AtomicInteger mPeakLevelBits = new AtomicInteger(); private final AtomicInteger mPeakLevelBits = new AtomicInteger();
private volatile AudioSegment mCurrentAudioSegment; private AudioSegment mCurrentAudioSegment;
private Listener<IdentifierCollection> mIdentifierCollectionListener; private Listener<IdentifierCollection> mIdentifierCollectionListener;
private boolean mDropDuplicates; private boolean mDropDuplicates;
private boolean mMetadataSent = false; private boolean mMetadataSent = false;
private boolean mMuted; private boolean mMuted;
private boolean mDisabled; private boolean mDisabled;
private volatile TalkgroupHold mHold;
private Listener<TalkgroupHold> mHoldListener;
private volatile Runnable mPlaybackListener;
private volatile ReplaySource mPendingReplay;
private volatile ReplaySource mReplay;
private float[] mAudioSegmentStartTone; private float[] mAudioSegmentStartTone;
private float[] mAudioSegmentDropTone; private float[] mAudioSegmentDropTone;
private int mCurrentBufferIndex = -1; private int mCurrentBufferIndex = -1;
@@ -112,114 +107,6 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
} }
} }
/**
* Hold talkgroup for this channel, or null. While a talkgroup is held, only calls to the talkgroup play on this
* channel, including calls that are otherwise flagged as do-not-monitor. The audio playback manager is
* responsible for steering calls to the channel; use {@link AudioPlaybackManager#setHold(int, TalkgroupHold)}.
*/
public TalkgroupHold getHold()
{
return mHold;
}
/**
* Sets or clears (null) the hold talkgroup. A call that is playing and doesn't match the hold talkgroup stops
* at the next audio interval.
*/
void setHold(TalkgroupHold hold)
{
mHold = hold;
Listener<TalkgroupHold> listener = mHoldListener;
if(listener != null)
{
listener.receive(hold);
}
}
/**
* Registers a single listener to be notified when the hold talkgroup is set (non-null) or cleared (null).
*/
public void setHoldListener(Listener<TalkgroupHold> listener)
{
mHoldListener = listener;
}
/**
* Indicates if the audio segment is allowed on this channel by the hold talkgroup.
*/
public boolean isAllowedByHold(AudioSegment audioSegment)
{
TalkgroupHold hold = mHold;
return hold == null || hold.matches(audioSegment);
}
/**
* Indicates if this channel is currently playing (or about to play) a call to its hold talkgroup.
*/
boolean isPlayingHeldTalkgroup()
{
TalkgroupHold hold = mHold;
AudioSegment current = mCurrentAudioSegment;
return hold != null && current != null && hold.matches(current);
}
/**
* Registers a single listener to be notified when this channel starts or stops playing a call audio segment or a
* replay. The listener reads the state from {@link #getCurrentAudioSegment()} and {@link #getReplay()}. Notified
* on the audio playback thread. Used by the audio playback manager.
*/
void setPlaybackListener(Runnable listener)
{
mPlaybackListener = listener;
}
/**
* Replays the recorded call on this channel. The replay takes over the channel at the next audio interval: a
* call that is playing is dropped and a replay that is playing is stopped. Calls queued for the channel play
* after the replay finishes. Use {@link AudioPlaybackManager#replay(ReplaySource)}.
*/
void startReplay(ReplaySource replay)
{
mPendingReplay = replay;
}
/**
* Replay that is playing on this channel, or null.
*/
public ReplaySource getReplay()
{
return mReplay;
}
/**
* Indicates if this channel is replaying (or about to replay) a recorded call.
*/
public boolean isReplaying()
{
ReplaySource replay = mReplay;
return mPendingReplay != null || (replay != null && !replay.isFinished());
}
/**
* Audio segment that this channel is currently playing, or null.
*/
public AudioSegment getCurrentAudioSegment()
{
return mCurrentAudioSegment;
}
private void notifyPlayback()
{
Runnable listener = mPlaybackListener;
if(listener != null)
{
listener.run();
}
}
/** /**
* Indicates if this audio channel is enabled. * Indicates if this audio channel is enabled.
*/ */
@@ -268,7 +155,7 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
*/ */
public boolean hasAudioSegment() public boolean hasAudioSegment()
{ {
return mCurrentAudioSegment != null || mReplay != null; return mCurrentAudioSegment != null;
} }
/** /**
@@ -346,13 +233,6 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
*/ */
private float[] getNextAudio() private float[] getNextAudio()
{ {
float[] replayAudio = getReplayAudio();
if(replayAudio != null)
{
return replayAudio;
}
if(mAudioBuffer.isFull()) if(mAudioBuffer.isFull())
{ {
return mAudioBuffer.get(); return mAudioBuffer.get();
@@ -422,56 +302,6 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
return audio; return audio;
} }
/**
* Starts a pending replay and provides the next replay audio. Audio thread.
* @return replay audio, or null when no replay is playing (normal call playback continues)
*/
private float[] getReplayAudio()
{
ReplaySource pending = mPendingReplay;
if(pending != null)
{
mPendingReplay = null;
if(mReplay != null)
{
mReplay.stop();
}
//The replay takes over the channel: drop the buffered audio and the call that is playing
mAudioBuffer.flush();
if(mCurrentAudioSegment != null)
{
disposeCurrentAudioSegment();
clearMetadata();
}
mReplay = pending;
notifyPlayback();
notify(AudioEvent.Type.REPLAY_STARTED);
}
ReplaySource replay = mReplay;
if(replay == null)
{
return null;
}
float[] audio = replay.next();
if(audio == null)
{
mReplay = null;
notifyPlayback();
notify(AudioEvent.Type.REPLAY_STOPPED);
}
return audio;
}
/** /**
* Notifies listener(s) of the audio event. * Notifies listener(s) of the audio event.
* @param eventType to notify for this channel * @param eventType to notify for this channel
@@ -512,20 +342,7 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
*/ */
private boolean isThrowaway(AudioSegment audioSegment) private boolean isThrowaway(AudioSegment audioSegment)
{ {
if(audioSegment == null) return audioSegment != null && (audioSegment.isDoNotMonitor() || mDropDuplicates && (audioSegment.isDuplicate()));
{
return false;
}
TalkgroupHold hold = mHold;
if(hold != null)
{
//A held talkgroup plays even when do-not-monitor, and nothing else plays on a held channel
return !hold.matches(audioSegment) || (mDropDuplicates && audioSegment.isDuplicate());
}
return audioSegment.isDoNotMonitor() || mDropDuplicates && (audioSegment.isDuplicate());
} }
/** /**
@@ -571,18 +388,9 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
{ {
MyEventBus.getGlobalEventBus().unregister(this); MyEventBus.getGlobalEventBus().unregister(this);
ReplaySource replay = mReplay;
if(replay != null)
{
replay.stop();
}
disposeCurrentAudioSegment(); disposeCurrentAudioSegment();
mAudioEventBroadcaster.clear(); mAudioEventBroadcaster.clear();
mIdentifierCollectionListener = null; mIdentifierCollectionListener = null;
mHoldListener = null;
mPlaybackListener = null;
} }
/** /**
@@ -693,7 +501,6 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
mCurrentAudioSegment.decrementConsumerCount(); mCurrentAudioSegment.decrementConsumerCount();
mCurrentAudioSegment.removeIdentifierUpdateNotificationListener(this); mCurrentAudioSegment.removeIdentifierUpdateNotificationListener(this);
mCurrentAudioSegment = null; mCurrentAudioSegment = null;
notifyPlayback();
} }
} }
@@ -731,7 +538,6 @@ public class AudioChannel implements Listener<IdentifierUpdateNotification>
if(audioSegment != null) if(audioSegment != null)
{ {
notifyPlayback();
mCurrentAudioSegment.addIdentifierUpdateNotificationListener(this); mCurrentAudioSegment.addIdentifierUpdateNotificationListener(this);
broadcast(mCurrentAudioSegment.getIdentifierCollection()); broadcast(mCurrentAudioSegment.getIdentifierCollection());
} }

View File

@@ -53,7 +53,6 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
private static final Logger mLog = LoggerFactory.getLogger(AudioPlaybackManager.class); private static final Logger mLog = LoggerFactory.getLogger(AudioPlaybackManager.class);
private final AudioSegmentPrioritySorter mAudioSegmentPrioritySorter = new AudioSegmentPrioritySorter(); private final AudioSegmentPrioritySorter mAudioSegmentPrioritySorter = new AudioSegmentPrioritySorter();
private final Broadcaster<AudioEvent> mControllerBroadcaster = new Broadcaster<>(); private final Broadcaster<AudioEvent> mControllerBroadcaster = new Broadcaster<>();
private final Broadcaster<ChannelPlayback> mPlaybackBroadcaster = new Broadcaster<>();
private final List<AudioSegment> mAudioSegments = new ArrayList<>(); private final List<AudioSegment> mAudioSegments = new ArrayList<>();
private final List<AudioSegment> mPendingAudioSegments = new ArrayList<>(); private final List<AudioSegment> mPendingAudioSegments = new ArrayList<>();
private final LinkedTransferQueue<AudioSegment> mNewAudioSegmentQueue = new LinkedTransferQueue<>(); private final LinkedTransferQueue<AudioSegment> mNewAudioSegmentQueue = new LinkedTransferQueue<>();
@@ -62,8 +61,6 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
private AudioPlaybackDeviceDescriptor mAudioPlaybackDevice; private AudioPlaybackDeviceDescriptor mAudioPlaybackDevice;
private AudioOutput mAudioOutput; private AudioOutput mAudioOutput;
private ScheduledFuture<?> mProcessingTask; private ScheduledFuture<?> mProcessingTask;
private final TalkgroupHold[] mHolds = new TalkgroupHold[2];
private final long[] mHoldActivity = new long[2];
/** /**
* Constructs an instance. * Constructs an instance.
@@ -117,8 +114,6 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
*/ */
private void processAudioSegments() private void processAudioSegments()
{ {
updateHoldActivity();
//Process new audio segments queue. If segment has audio, queue it for replay, otherwise place in pending queue //Process new audio segments queue. If segment has audio, queue it for replay, otherwise place in pending queue
AudioSegment newSegment = mNewAudioSegmentQueue.poll(); AudioSegment newSegment = mNewAudioSegmentQueue.poll();
@@ -187,8 +182,7 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
{ {
audioSegment = it.next(); audioSegment = it.next();
if((audioSegment.isDoNotMonitor() && getHoldingChannelIndex(audioSegment) < 0) || if(audioSegment.isDoNotMonitor() || (audioSegment.isDuplicate() &&
(audioSegment.isDuplicate() &&
mUserPreferences.getCallManagementPreference().isDuplicatePlaybackSuppressionEnabled())) mUserPreferences.getCallManagementPreference().isDuplicatePlaybackSuppressionEnabled()))
{ {
it.remove(); it.remove();
@@ -239,7 +233,20 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
try try
{ {
assignAudioSegments(mAudioSegments, mAudioOutput.getAudioProvider().getAudioChannels()); //Assign empty audio outputs first
for(AudioChannel audioChannel: mAudioOutput.getAudioProvider().getAudioChannels())
{
if(audioChannel.isEmpty())
{
audioChannel.play(mAudioSegments.removeFirst());
if(mAudioSegments.isEmpty())
{
return;
}
}
}
replaceLowerPriorityQueuedSegments(mAudioSegments, mAudioOutput.getAudioProvider().getAudioChannels());
} }
finally finally
{ {
@@ -263,352 +270,6 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
} }
} }
/**
* Assigns waiting audio segments, in priority order, to empty audio channels. Calls to a hold talkgroup only go to
* the channel that holds the talkgroup, and other calls only go to channels without a hold talkgroup.
*
* @param waiting audio segments, sorted by playback priority. Assigned segments are removed.
* @param audioChannels to assign to.
*/
static void assignAudioSegments(List<AudioSegment> waiting, List<AudioChannel> audioChannels)
{
Iterator<AudioSegment> it = waiting.iterator();
while(it.hasNext())
{
AudioSegment audioSegment = it.next();
AudioChannel holding = getHoldingChannel(audioSegment, audioChannels);
AudioChannel target = null;
if(holding != null)
{
if(holding.isEmpty())
{
target = holding;
}
}
else
{
for(AudioChannel audioChannel: audioChannels)
{
if(audioChannel.getHold() == null && audioChannel.isEmpty() && !audioChannel.isReplaying())
{
target = audioChannel;
break;
}
}
}
if(target != null)
{
it.remove();
target.play(audioSegment);
}
}
//Priority replacement of queued segments only applies to channels and calls without a hold talkgroup
List<AudioChannel> unheld = new ArrayList<>();
for(AudioChannel audioChannel: audioChannels)
{
if(audioChannel.getHold() == null && !audioChannel.isReplaying())
{
unheld.add(audioChannel);
}
}
if(!unheld.isEmpty() && !waiting.isEmpty())
{
List<AudioSegment> unmatched = new ArrayList<>();
it = waiting.iterator();
while(it.hasNext())
{
AudioSegment audioSegment = it.next();
if(getHoldingChannel(audioSegment, audioChannels) == null)
{
unmatched.add(audioSegment);
it.remove();
}
}
replaceLowerPriorityQueuedSegments(unmatched, unheld);
waiting.addAll(unmatched);
}
}
/**
* Channel that holds the talkgroup of the audio segment, or null.
*/
static AudioChannel getHoldingChannel(AudioSegment audioSegment, List<AudioChannel> audioChannels)
{
for(AudioChannel audioChannel: audioChannels)
{
TalkgroupHold hold = audioChannel.getHold();
if(hold != null && hold.matches(audioSegment))
{
return audioChannel;
}
}
return null;
}
/**
* Index of the channel that holds the talkgroup of the audio segment, or -1.
*/
private int getHoldingChannelIndex(AudioSegment audioSegment)
{
for(int x = 0; x < mHolds.length; x++)
{
TalkgroupHold hold = mHolds[x];
if(hold != null && hold.matches(audioSegment))
{
return x;
}
}
return -1;
}
/**
* Sets (or clears, with null) the hold talkgroup for the audio channel. Setting a talkgroup that another channel
* holds moves the hold to this channel. Queued calls that don't match the hold talkgroup are returned for
* assignment to another channel, and a call that is playing and doesn't match stops.
*
* @param channelIndex of the audio channel (0 = left/mono, 1 = right)
* @param hold talkgroup or null to release the hold
*/
public void setHold(int channelIndex, TalkgroupHold hold)
{
if(channelIndex < 0 || channelIndex >= mHolds.length)
{
return;
}
mAudioChannelsLock.lock();
try
{
if(hold != null)
{
for(int x = 0; x < mHolds.length; x++)
{
if(x != channelIndex && hold.isSameTalkgroup(mHolds[x]))
{
applyHold(x, null);
}
}
}
applyHold(channelIndex, hold);
}
finally
{
mAudioChannelsLock.unlock();
}
mLog.info("Audio channel " + channelIndex + (hold != null ? " hold talkgroup [" + hold + "]" :
" hold talkgroup released"));
}
/**
* Applies the hold to the channel. Audio channels lock must be held.
*/
private void applyHold(int channelIndex, TalkgroupHold hold)
{
mHolds[channelIndex] = hold;
mHoldActivity[channelIndex] = System.currentTimeMillis();
if(mAudioOutput != null)
{
List<AudioChannel> channels = mAudioOutput.getAudioProvider().getAudioChannels();
if(channelIndex < channels.size())
{
AudioChannel channel = channels.get(channelIndex);
channel.setHold(hold);
if(hold != null)
{
//Return queued calls that can no longer play on this channel
List<AudioSegment> keep = new ArrayList<>();
AudioSegment queued = channel.pollQueuedAudioSegment();
while(queued != null)
{
if(hold.matches(queued))
{
keep.add(queued);
}
else
{
mNewAudioSegmentQueue.add(queued);
}
queued = channel.pollQueuedAudioSegment();
}
for(AudioSegment segment: keep)
{
channel.play(segment);
}
}
}
}
}
/**
* Registers the listener to be notified when an audio channel starts or stops playing a call. Notified on the
* audio playback thread.
*/
public void addPlaybackListener(Listener<ChannelPlayback> listener)
{
mPlaybackBroadcaster.addListener(listener);
}
public void removePlaybackListener(Listener<ChannelPlayback> listener)
{
mPlaybackBroadcaster.removeListener(listener);
}
/**
* Current playback state of each audio channel, for a listener that registers after playback started.
*/
public List<ChannelPlayback> getChannelPlayback()
{
List<ChannelPlayback> playback = new ArrayList<>();
List<AudioChannel> channels = getAudioChannels();
for(int x = 0; x < channels.size(); x++)
{
playback.add(getChannelPlayback(channels.get(x), x, channels.size()));
}
return playback;
}
private static ChannelPlayback getChannelPlayback(AudioChannel channel, int channelIndex, int channelCount)
{
AudioSegment current = channel.getCurrentAudioSegment();
ReplaySource replay = channel.getReplay();
return new ChannelPlayback(channelIndex, channel.getChannelName(), channelCount,
current != null ? current.getId() : 0, replay != null && !replay.isFinished() ? replay.getCallId() : 0);
}
/**
* Replays a recorded call through the audio channels. A channel that is already replaying is reused, otherwise
* an idle channel (left first), otherwise the left (or mono) channel, which drops the call that it is playing.
* Live calls aren't assigned to the channel while it replays.
*
* @param replay to play
* @return index of the channel that replays the call, or -1 if there is no audio output
*/
public int replay(ReplaySource replay)
{
mAudioChannelsLock.lock();
try
{
List<AudioChannel> channels = getAudioChannels();
if(channels.isEmpty())
{
return -1;
}
int selected = -1;
for(int x = 0; x < channels.size() && selected < 0; x++)
{
if(channels.get(x).isReplaying())
{
selected = x;
}
}
for(int x = 0; x < channels.size() && selected < 0; x++)
{
AudioChannel channel = channels.get(x);
if(!channel.hasAudioSegment() && channel.isEmpty())
{
selected = x;
}
}
if(selected < 0)
{
selected = 0;
}
channels.get(selected).startReplay(replay);
return selected;
}
finally
{
mAudioChannelsLock.unlock();
}
}
/**
* Hold talkgroup for the audio channel, or null.
*/
public TalkgroupHold getHold(int channelIndex)
{
return channelIndex >= 0 && channelIndex < mHolds.length ? mHolds[channelIndex] : null;
}
/**
* Updates the last activity time of each hold talkgroup and releases holds that have been idle longer than the
* automatic release time.
*/
private void updateHoldActivity()
{
int minutes = mUserPreferences.getPlaybackPreference().getHoldAutoReleaseMinutes();
long now = System.currentTimeMillis();
for(int x = 0; x < mHolds.length; x++)
{
TalkgroupHold hold = mHolds[x];
if(hold == null)
{
continue;
}
boolean active = false;
for(AudioSegment audioSegment: mAudioSegments)
{
if(hold.matches(audioSegment))
{
active = true;
break;
}
}
if(!active && mAudioOutput != null)
{
List<AudioChannel> channels = mAudioOutput.getAudioProvider().getAudioChannels();
active = x < channels.size() && channels.get(x).isPlayingHeldTalkgroup();
}
if(active)
{
mHoldActivity[x] = now;
}
else if(minutes > 0 && (now - mHoldActivity[x]) > TimeUnit.MINUTES.toMillis(minutes))
{
mLog.info("Releasing idle hold talkgroup [" + hold + "] after " + minutes + " minutes");
setHold(x, null);
}
}
}
/** /**
* Swaps audio segments queued on the audio channels for waiting audio segments that have a higher playback priority, * Swaps audio segments queued on the audio channels for waiting audio segments that have a higher playback priority,
* so that a segment queued behind the current playback can't hold a higher priority segment out of the channel. * so that a segment queued behind the current playback can't hold a higher priority segment out of the channel.
@@ -736,30 +397,6 @@ public class AudioPlaybackManager implements Listener<AudioSegment>, IAudioContr
//Note: audio output can use an alternate device if the requested device can't be used, so we assign //Note: audio output can use an alternate device if the requested device can't be used, so we assign
//the descriptor that was actually used by the audio output //the descriptor that was actually used by the audio output
mAudioPlaybackDevice = mAudioOutput.getAudioPlaybackDeviceDescriptor(); mAudioPlaybackDevice = mAudioOutput.getAudioPlaybackDeviceDescriptor();
//Re-apply hold talkgroups to the new channels (and drop a right channel hold for a mono device)
List<AudioChannel> channels = mAudioOutput.getAudioProvider().getAudioChannels();
for(int x = 0; x < channels.size(); x++)
{
final int channelIndex = x;
final AudioChannel channel = channels.get(x);
final int outputChannels = channels.size();
channel.setPlaybackListener(() -> mPlaybackBroadcaster.broadcast(
getChannelPlayback(channel, channelIndex, outputChannels)));
}
for(int x = 0; x < mHolds.length; x++)
{
if(x < channels.size())
{
channels.get(x).setHold(mHolds[x]);
}
else
{
mHolds[x] = null;
}
}
} }
finally finally
{ {

View File

@@ -1,49 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.audio.playback;
/**
* Notification that an audio channel started playing a call, or stopped playing.
*
* @param channelIndex of the audio channel in the audio output (0 = left/mono, 1 = right)
* @param channelName of the audio channel (LEFT, RIGHT or MONO)
* @param channelCount number of channels in the audio output
* @param audioSegmentId of the live call audio segment that is playing, or 0. This is the call key of the call in
* the call manager.
* @param replayCallId database id of the recorded call that is replaying, or 0.
*/
public record ChannelPlayback(int channelIndex, String channelName, int channelCount, long audioSegmentId,
long replayCallId)
{
/**
* Indicates if the channel is playing a live call or replaying a recorded call
*/
public boolean isPlaying()
{
return audioSegmentId != 0 || replayCallId != 0;
}
/**
* Indicates if the channel is replaying a recorded call
*/
public boolean isReplay()
{
return replayCallId != 0;
}
}

View File

@@ -1,154 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.audio.playback;
/**
* Audio of a recorded call that is replayed through an audio channel. The audio channel pulls the audio in 20 ms
* intervals on the audio playback thread, and the user interface pauses, seeks and stops it from the FX thread.
*/
public class ReplaySource
{
private final float[] mSamples;
private final long mCallId;
private final String mDescription;
private volatile int mPosition;
private volatile boolean mPaused;
private volatile boolean mStopped;
/**
* Constructs an instance
* @param samples of 8 kHz audio
* @param callId database id of the call that is replayed
* @param description of the call for display (e.g. TO and FROM)
*/
public ReplaySource(float[] samples, long callId, String description)
{
mSamples = samples;
mCallId = callId;
mDescription = description;
}
/**
* Database id of the replayed call
*/
public long getCallId()
{
return mCallId;
}
/**
* Description of the replayed call for display
*/
public String getDescription()
{
return mDescription;
}
/**
* Next 20 ms of audio, silence while paused, or null when the replay is finished or stopped. Audio thread.
*/
float[] next()
{
if(isFinished())
{
return null;
}
float[] audio = new float[AudioChannel.SAMPLES_PER_INTERVAL];
if(mPaused)
{
return audio;
}
int position = mPosition;
int length = Math.min(audio.length, mSamples.length - position);
System.arraycopy(mSamples, position, audio, 0, length);
mPosition = position + length;
return audio;
}
/**
* Indicates if the replay played to the end or was stopped
*/
public boolean isFinished()
{
return mStopped || mPosition >= mSamples.length;
}
/**
* Indicates if the replay played to the end, as opposed to being stopped or replaced
*/
public boolean isCompleted()
{
return !mStopped && mPosition >= mSamples.length;
}
public boolean isPaused()
{
return mPaused;
}
public void setPaused(boolean paused)
{
mPaused = paused;
}
/**
* Stops the replay. The audio channel releases it at the next audio interval.
*/
public void stop()
{
mStopped = true;
}
/**
* Moves the replay position
* @param fraction of the recording, 0.0 to 1.0
*/
public void seek(double fraction)
{
double clamped = Math.max(0.0, Math.min(1.0, fraction));
mPosition = (int)Math.min(mSamples.length, Math.round(mSamples.length * clamped));
}
/**
* Replay position in milliseconds
*/
public long getPositionMillis()
{
return mPosition * 1000L / 8000L;
}
/**
* Recording duration in milliseconds
*/
public long getDurationMillis()
{
return mSamples.length * 1000L / 8000L;
}
/**
* Replay position as a fraction of the recording, 0.0 to 1.0
*/
public double getFraction()
{
return mSamples.length > 0 ? (double)mPosition / mSamples.length : 1.0;
}
}

View File

@@ -1,167 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.audio.playback;
import io.github.dsheirer.audio.AudioSegment;
import io.github.dsheirer.database.call.CallRecord;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.identifier.IdentifierCollection;
import io.github.dsheirer.identifier.Role;
import io.github.dsheirer.identifier.patch.PatchGroup;
import io.github.dsheirer.identifier.patch.PatchGroupIdentifier;
import io.github.dsheirer.identifier.talkgroup.TalkgroupIdentifier;
import io.github.dsheirer.protocol.Protocol;
/**
* Hold talkgroup for an audio channel. While a channel holds a talkgroup, only calls to that talkgroup play on the
* channel and calls to the talkgroup are steered to the channel.
*
* A call matches when its TO talkgroup has the same protocol and value, or when its TO patch group is (or includes)
* the talkgroup. APCO-25 phase 1 and phase 2 are treated as the same protocol since a P25 system's talkgroups are
* used on both phase 1 and phase 2 traffic channels.
*
* @param protocol of the talkgroup
* @param talkgroup value
* @param label for display (formatted talkgroup and alias)
*/
public record TalkgroupHold(Protocol protocol, int talkgroup, String label)
{
/**
* Normalizes the protocol for comparison
*/
private static Protocol normalize(Protocol protocol)
{
return protocol == Protocol.APCO25_PHASE2 ? Protocol.APCO25 : protocol;
}
/**
* Indicates if the talkgroup identifier is this hold talkgroup
*/
public boolean matches(TalkgroupIdentifier identifier)
{
return identifier != null && identifier.getValue() != null && identifier.getValue() == talkgroup &&
normalize(identifier.getProtocol()) == normalize(protocol);
}
/**
* Indicates if the call identifiers have this hold talkgroup (or a patch group with it) as the TO identifier.
*/
public boolean matches(IdentifierCollection identifierCollection)
{
if(identifierCollection == null)
{
return false;
}
for(Identifier identifier: identifierCollection.getIdentifiers(Role.TO))
{
if(identifier instanceof TalkgroupIdentifier tg && matches(tg))
{
return true;
}
if(identifier instanceof PatchGroupIdentifier pgi && pgi.getValue() != null)
{
PatchGroup patchGroup = pgi.getValue();
if(matches(patchGroup.getPatchGroup()))
{
return true;
}
for(TalkgroupIdentifier patched: patchGroup.getPatchedTalkgroupIdentifiers())
{
if(matches(patched))
{
return true;
}
}
}
}
return false;
}
/**
* Indicates if the audio segment is a call to this hold talkgroup.
*/
public boolean matches(AudioSegment audioSegment)
{
return audioSegment != null && matches(audioSegment.getIdentifierCollection());
}
/**
* Creates a hold for the TO talkgroup (or patch group) of the call identifiers.
* @param identifierCollection of a call
* @param label for display
* @return hold or null if the call doesn't have a TO talkgroup
*/
public static TalkgroupHold from(IdentifierCollection identifierCollection, String label)
{
if(identifierCollection == null)
{
return null;
}
Identifier to = identifierCollection.getToIdentifier();
if(to instanceof PatchGroupIdentifier pgi && pgi.getValue() != null && pgi.getValue().getPatchGroup() != null)
{
to = pgi.getValue().getPatchGroup();
}
if(to instanceof TalkgroupIdentifier tg && tg.getValue() != null && tg.getValue() > 0)
{
return new TalkgroupHold(tg.getProtocol(), tg.getValue(), label != null ? label : tg.toString());
}
return null;
}
/**
* Creates a hold for the TO talkgroup of a stored call.
* @param call with a TO talkgroup
* @param toAlias current alias name of the TO talkgroup for the label, or null
* @return hold or null if the call doesn't have a TO talkgroup
*/
public static TalkgroupHold from(CallRecord call, String toAlias)
{
if(call == null || !call.hasTalkgroup() || call.getToValue() > Integer.MAX_VALUE)
{
return null;
}
String label = call.getToId() + (toAlias != null ? " " + toAlias : "");
return new TalkgroupHold(call.getProtocolValue(), call.getToValue().intValue(), label);
}
/**
* Indicates if the other hold is for the same talkgroup (ignoring the label).
*/
public boolean isSameTalkgroup(TalkgroupHold other)
{
return other != null && other.talkgroup == talkgroup && normalize(other.protocol) == normalize(protocol);
}
@Override
public String toString()
{
return label;
}
}

View File

@@ -1,412 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.call;
import io.github.dsheirer.alias.AliasList;
import io.github.dsheirer.audio.AudioSegment;
import io.github.dsheirer.controller.NamingThreadFactory;
import io.github.dsheirer.database.DatabaseManager;
import io.github.dsheirer.database.call.CallRecord;
import io.github.dsheirer.database.call.CallState;
import io.github.dsheirer.database.call.PatchedTalkgroup;
import io.github.dsheirer.identifier.Form;
import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.identifier.IdentifierClass;
import io.github.dsheirer.identifier.IdentifierCollection;
import io.github.dsheirer.identifier.Role;
import io.github.dsheirer.identifier.configuration.DecoderTypeConfigurationIdentifier;
import io.github.dsheirer.identifier.configuration.FrequencyConfigurationIdentifier;
import io.github.dsheirer.identifier.integer.IntegerIdentifier;
import io.github.dsheirer.identifier.patch.PatchGroupIdentifier;
import io.github.dsheirer.identifier.radio.FullyQualifiedRadioIdentifier;
import io.github.dsheirer.identifier.talkgroup.FullyQualifiedTalkgroupIdentifier;
import io.github.dsheirer.identifier.talkgroup.TalkgroupIdentifier;
import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.protocol.Protocol;
import io.github.dsheirer.record.CallRecorder;
import io.github.dsheirer.sample.Broadcaster;
import io.github.dsheirer.sample.Listener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
/**
* Manages the life-cycle of every call: the single audio segment listener for calls.
*
* Each audio segment is a call. The call manager creates the call record as soon as the call has audio (or is
* identified as encrypted), updates it as the call identifiers change and completes it when the call ends. Each
* change is saved to the call database and broadcast to the call listeners (Calls tab, and later external
* subscribers), so they see the same call activity. The {@link CallRecorder} records the call audio and fills in
* the recording details of the call record.
*
* Calls are processed on a single call manager thread every 200 milliseconds.
*/
public class CallManager implements Listener<AudioSegment>
{
private final static Logger mLog = LoggerFactory.getLogger(CallManager.class);
private static final long PROCESSING_INTERVAL_MS = 200;
private final LinkedTransferQueue<AudioSegment> mNewAudioSegmentQueue = new LinkedTransferQueue<>();
private final List<TrackedCall> mTrackedCalls = new ArrayList<>();
private final Broadcaster<CallRecord> mCallBroadcaster = new Broadcaster<>();
private final ScheduledExecutorService mExecutor =
Executors.newSingleThreadScheduledExecutor(new NamingThreadFactory("sdrtrunk call manager"));
private final UserPreferences mUserPreferences;
private final DatabaseManager mDatabaseManager;
private final CallRecorder mCallRecorder;
private ScheduledFuture<?> mProcessorHandle;
/**
* Constructs an instance
* @param userPreferences for call recording and identifier formatting
* @param databaseManager to store the calls, or null to track and record calls without storing them
*/
public CallManager(UserPreferences userPreferences, DatabaseManager databaseManager)
{
mUserPreferences = userPreferences;
mDatabaseManager = databaseManager;
mCallRecorder = new CallRecorder(userPreferences);
}
/**
* Starts the manager and begins call tracking and audio recording.
*/
public void start()
{
if(mProcessorHandle == null)
{
mProcessorHandle = mExecutor.scheduleWithFixedDelay(this::processSafely, 0, PROCESSING_INTERVAL_MS,
TimeUnit.MILLISECONDS);
}
}
/**
* Stops the manager, completing any calls and recordings that are still in progress.
*/
public void stop()
{
if(mProcessorHandle != null)
{
mProcessorHandle.cancel(false);
mProcessorHandle = null;
try
{
mExecutor.submit(() -> {
process();
for(TrackedCall trackedCall: mTrackedCalls)
{
trackedCall.complete();
}
mTrackedCalls.clear();
}).get(10, TimeUnit.SECONDS);
}
catch(Exception e)
{
mLog.error("Error completing calls in progress during shutdown", e);
}
mExecutor.shutdownNow();
}
}
/**
* Registers the listener to receive a snapshot of each call when it starts, changes and completes. Snapshots
* of the same call share the same {@link CallRecord#getCallKey()}, which is the {@link AudioSegment#getId()} of
* the call's audio segment. Notified on the call recorder thread.
*/
public void addCallListener(Listener<CallRecord> listener)
{
mCallBroadcaster.addListener(listener);
}
public void removeCallListener(Listener<CallRecord> listener)
{
mCallBroadcaster.removeListener(listener);
}
/**
* Primary receive method for incoming audio segments. The consumer count of the segment is already incremented
* for this manager.
*/
@Override
public void receive(AudioSegment audioSegment)
{
mNewAudioSegmentQueue.add(audioSegment);
}
private void processSafely()
{
try
{
process();
}
catch(Throwable t)
{
mLog.error("Error while processing calls", t);
}
}
/**
* Processes new and tracked audio segments. Call recorder thread only.
*/
private void process()
{
AudioSegment audioSegment = mNewAudioSegmentQueue.poll();
while(audioSegment != null)
{
mTrackedCalls.add(new TrackedCall(audioSegment, audioSegment.getId()));
audioSegment = mNewAudioSegmentQueue.poll();
}
Iterator<TrackedCall> it = mTrackedCalls.iterator();
while(it.hasNext())
{
TrackedCall trackedCall = it.next();
if(trackedCall.process())
{
it.remove();
}
}
}
/**
* Updates the call record fields from the audio segment.
*/
void update(CallRecord call, AudioSegment audioSegment)
{
IdentifierCollection collection = audioSegment.getIdentifierCollection();
AliasList aliasList = audioSegment.getAliasList();
Identifier to = collection.getToIdentifier();
Identifier from = collection.getFromIdentifier();
Protocol protocol = to != null ? to.getProtocol() : (from != null ? from.getProtocol() : null);
if(protocol == null || protocol == Protocol.UNKNOWN)
{
Identifier decoder = collection.getIdentifier(IdentifierClass.CONFIGURATION, Form.DECODER_TYPE, Role.ANY);
if(decoder instanceof DecoderTypeConfigurationIdentifier dtci && dtci.getValue() != null)
{
protocol = dtci.getValue().getProtocol();
}
}
call.setProtocol(protocol != null ? protocol.name() : null);
call.setSystem(getString(collection, Form.SYSTEM));
call.setSite(getString(collection, Form.SITE));
call.setChannel(getString(collection, Form.CHANNEL));
Identifier frequency = collection.getIdentifier(IdentifierClass.CONFIGURATION, Form.CHANNEL_FREQUENCY, Role.ANY);
if(frequency instanceof FrequencyConfigurationIdentifier fci && fci.getValue() != null)
{
call.setFrequency(fci.getValue());
}
call.setTimeslot(audioSegment.getTimeslot());
var format = mUserPreferences.getTalkgroupFormatPreference();
call.setToId(to != null ? format.format(to) : null);
call.setToValue(getValue(to));
call.setToForm(to != null ? to.getForm().name() : null);
call.setToFullyQualified(to instanceof FullyQualifiedTalkgroupIdentifier fqt ?
fqt.getFullyQualifiedTalkgroupAddress() : null);
call.setFromId(from != null ? format.format(from) : null);
call.setFromValue(getValue(from));
call.setFromForm(from != null ? from.getForm().name() : null);
call.setFromFullyQualified(from instanceof FullyQualifiedRadioIdentifier fqr ?
fqr.getFullyQualifiedRadioAddress() : null);
call.setAliasList(aliasList != null ? aliasList.getName() : null);
call.setPatchedTalkgroups(getPatchedTalkgroups(to));
List<Identifier> talkerAliases = collection.getIdentifiers(Form.TALKER_ALIAS);
call.setTalkerAlias(talkerAliases.isEmpty() ? null : talkerAliases.getFirst().toString());
call.setEncrypted(audioSegment.isEncrypted());
call.setDuplicate(audioSegment.isDuplicate());
call.setPriority(audioSegment.monitorPriorityProperty().get());
call.setAliasRecord(audioSegment.recordAudioProperty().get());
call.setStartTime(audioSegment.getStartTimestamp());
}
/**
* Talkgroups patched into the patch group TO identifier, or an empty list.
*/
static List<PatchedTalkgroup> getPatchedTalkgroups(Identifier to)
{
if(!(to instanceof PatchGroupIdentifier pgi) || pgi.getValue() == null)
{
return List.of();
}
List<PatchedTalkgroup> patched = new ArrayList<>();
for(TalkgroupIdentifier talkgroup: pgi.getValue().getPatchedTalkgroupIdentifiers())
{
if(talkgroup != null && talkgroup.getValue() != null)
{
patched.add(new PatchedTalkgroup(talkgroup.getValue(),
talkgroup instanceof FullyQualifiedTalkgroupIdentifier fqt ?
fqt.getFullyQualifiedTalkgroupAddress() : null));
}
}
return patched;
}
private static String getString(IdentifierCollection collection, Form form)
{
Identifier identifier = collection.getIdentifier(IdentifierClass.CONFIGURATION, form, Role.ANY);
return identifier != null && identifier.getValue() != null ? identifier.getValue().toString() : null;
}
/**
* Numeric value of a talkgroup, patch group (the patch group talkgroup) or radio identifier, or null.
*/
static Long getValue(Identifier identifier)
{
if(identifier instanceof PatchGroupIdentifier pgi && pgi.getValue() != null &&
pgi.getValue().getPatchGroup() != null)
{
return pgi.getValue().getPatchGroup().getValue().longValue();
}
if(identifier instanceof IntegerIdentifier ii && ii.getValue() != null)
{
return ii.getValue().longValue();
}
return null;
}
/**
* Content of a call snapshot that is compared to detect a change that needs to be saved and broadcast.
*/
private static String getSignature(CallRecord call)
{
return call.getStartTime() + "|" + call.getCallState() + "|" + call.getProtocol() + "|" + call.getSystem() +
"|" + call.getSite() + "|" + call.getChannel() + "|" + call.getFrequency() + "|" + call.getToId() + "|" +
call.getToForm() + "|" + call.getFromId() + "|" + call.getFromForm() + "|" + call.getAliasList() + "|" + call.getPatchedTalkgroups() + "|" +
call.getTalkerAlias() + "|" +
call.isEncrypted() + "|" + call.isDuplicate() + "|" + call.getPriority() + "|" + call.isAliasRecord() + "|" +
call.getRecordingState() + "|" + call.getFilePath() + "|" + call.getEndTime();
}
/**
* A call that is being tracked and possibly recorded. Call recorder thread only.
*/
private class TrackedCall
{
private final AudioSegment mAudioSegment;
private final CallRecord mCall = new CallRecord();
private final DatabaseManager.CallHandle mHandle;
private final CallRecorder.Recording mRecording;
private String mLastSignature;
private boolean mPublished;
TrackedCall(AudioSegment audioSegment, long callKey)
{
mAudioSegment = audioSegment;
mRecording = mCallRecorder.createRecording(audioSegment);
mCall.setCallKey(callKey);
mHandle = mDatabaseManager != null ? mDatabaseManager.createHandle() : null;
}
/**
* Processes the call.
* @return true when the call is complete and should no longer be tracked
*/
boolean process()
{
boolean complete = mAudioSegment.isComplete();
boolean hasAudio = mAudioSegment.hasAudio();
if(complete)
{
if(hasAudio || mPublished || mAudioSegment.isEncrypted())
{
complete();
}
mAudioSegment.decrementConsumerCount();
return true;
}
//Wait for audio (or an encrypted call) before creating the call, so that segments that never have audio
//don't create empty calls
if(!hasAudio && !mAudioSegment.isEncrypted())
{
return false;
}
update(mCall, mAudioSegment);
mRecording.update(mCall);
publish();
return false;
}
/**
* Completes the call and its recording.
*/
void complete()
{
update(mCall, mAudioSegment);
mRecording.complete(mCall);
mCall.setEndTime(mAudioSegment.hasAudio() ? mAudioSegment.getEndTimestamp() : System.currentTimeMillis());
mCall.setCallState(CallState.COMPLETE);
publish();
}
/**
* Saves and broadcasts a snapshot of the call when it changed.
*/
private void publish()
{
String signature = getSignature(mCall);
if(!Objects.equals(signature, mLastSignature))
{
mLastSignature = signature;
CallRecord snapshot = mCall.copy();
mPublished = true;
if(mDatabaseManager != null)
{
//The database writer sets the row id on its own copy
mDatabaseManager.save(mHandle, snapshot.copy());
}
mCallBroadcaster.broadcast(snapshot);
}
}
}
}

View File

@@ -1,347 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import io.github.dsheirer.database.call.CallRepository;
import io.github.dsheirer.database.call.ICallRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
/**
* An open connection pool to one database and schema, with the sdrtrunk schema installation logic.
*/
public class CallDatabase implements AutoCloseable
{
private static final Logger LOGGER = LoggerFactory.getLogger(CallDatabase.class);
/**
* Version of the sdrtrunk tables that this release creates. Increment and add an upgrade step to
* {@link #getUpgradeStatements(int)} when the tables change.
*/
public static final int SCHEMA_VERSION = 2;
public static final String SCHEMA_INFO_TABLE = "schema_info";
private final DatabaseConfiguration mConfiguration;
private final HikariDataSource mDataSource;
private final ICallRepository mCallRepository;
/**
* Opens a connection pool for the configuration. The schema isn't created or checked.
* @param configuration for the database
* @param databaseDirectory for the built-in database files
* @throws SQLException if the database can't be reached
*/
public CallDatabase(DatabaseConfiguration configuration, Path databaseDirectory) throws SQLException
{
mConfiguration = configuration;
mCallRepository = new CallRepository(configuration.schema());
if(configuration.type() == DatabaseType.H2)
{
try
{
Files.createDirectories(databaseDirectory);
}
catch(Exception e)
{
throw new SQLException("Unable to create the database directory [" + databaseDirectory + "]", e);
}
}
try
{
Class.forName(configuration.type().getDialect().getDriverClass());
}
catch(ClassNotFoundException cnfe)
{
throw new SQLException("Database driver isn't available: " + configuration.type().getDialect().getDriverClass(), cnfe);
}
HikariConfig config = new HikariConfig();
config.setPoolName("sdrtrunk-db-" + configuration.type().name().toLowerCase(Locale.ROOT));
config.setJdbcUrl(configuration.getJdbcUrl(databaseDirectory));
config.setDriverClassName(configuration.type().getDialect().getDriverClass());
if(configuration.type().isNetwork())
{
config.setUsername(configuration.user());
config.setPassword(configuration.password());
}
else
{
config.setUsername("sa");
config.setPassword("");
}
config.setMaximumPoolSize(4);
config.setMinimumIdle(1);
config.setConnectionTimeout(10_000);
config.setValidationTimeout(5_000);
//Fail immediately when the database can't be reached, so the user gets an answer
config.setInitializationFailTimeout(1);
try
{
mDataSource = new HikariDataSource(config);
}
catch(Exception e)
{
Throwable cause = e.getCause() != null ? e.getCause() : e;
throw new SQLException("Unable to connect to " + configuration.getDescription() + ": " +
cause.getMessage(), cause);
}
}
/**
* Configuration for this database
*/
public DatabaseConfiguration getConfiguration()
{
return mConfiguration;
}
/**
* Repository for the calls table in this schema
*/
public ICallRepository getCallRepository()
{
return mCallRepository;
}
/**
* Pooled connection. Close it to return it to the pool.
*/
public Connection getConnection() throws SQLException
{
return mDataSource.getConnection();
}
/**
* Determines whether the configured schema exists and whether it holds sdrtrunk tables.
*/
public SchemaStatus getSchemaStatus() throws SQLException
{
try(Connection connection = getConnection())
{
return getSchemaStatus(connection, mConfiguration.schema());
}
}
/**
* Determines the status of the named schema.
*/
public static SchemaStatus getSchemaStatus(Connection connection, String schema) throws SQLException
{
boolean schemaExists;
try(PreparedStatement statement = connection.prepareStatement("SELECT COUNT(*) FROM " +
"information_schema.schemata WHERE LOWER(schema_name) = ?"))
{
statement.setString(1, schema.toLowerCase(Locale.ROOT));
try(ResultSet rs = statement.executeQuery())
{
schemaExists = rs.next() && rs.getLong(1) > 0;
}
}
if(!schemaExists)
{
return SchemaStatus.MISSING;
}
try(PreparedStatement statement = connection.prepareStatement("SELECT COUNT(*) FROM " +
"information_schema.tables WHERE LOWER(table_schema) = ? AND LOWER(table_name) = ?"))
{
statement.setString(1, schema.toLowerCase(Locale.ROOT));
statement.setString(2, SCHEMA_INFO_TABLE);
try(ResultSet rs = statement.executeQuery())
{
return rs.next() && rs.getLong(1) > 0 ? SchemaStatus.SDRTRUNK : SchemaStatus.EMPTY;
}
}
}
/**
* Number of calls stored in the schema, or 0 if the schema doesn't have sdrtrunk tables.
*/
public long getCallCount() throws SQLException
{
if(getSchemaStatus() != SchemaStatus.SDRTRUNK)
{
return 0;
}
try(Connection connection = getConnection())
{
return mCallRepository.count(connection);
}
}
/**
* Creates the schema and tables when they don't exist and upgrades the tables of an older version.
* @throws SQLException on error, or if the schema was created by a newer version of sdrtrunk
*/
public void install() throws SQLException
{
DatabaseType type = mConfiguration.type();
String schema = mConfiguration.schema();
try(Connection connection = getConnection(); Statement statement = connection.createStatement())
{
statement.execute(type.getDialect().getCreateSchemaStatement(schema));
statement.execute("CREATE TABLE IF NOT EXISTS " + schema + "." + SCHEMA_INFO_TABLE +
" (version INT NOT NULL)");
int version = getVersion(connection);
if(version > SCHEMA_VERSION)
{
throw new SQLException("Schema [" + schema + "] was created by a newer version of sdrtrunk (schema " +
"version " + version + "). This version supports schema version " + SCHEMA_VERSION + ".");
}
if(version < SCHEMA_VERSION)
{
for(String sql: getUpgradeStatements(version))
{
statement.execute(sql);
}
if(version == 0)
{
statement.executeUpdate("INSERT INTO " + schema + "." + SCHEMA_INFO_TABLE +
" (version) VALUES (" + SCHEMA_VERSION + ")");
}
else
{
statement.executeUpdate("UPDATE " + schema + "." + SCHEMA_INFO_TABLE + " SET version = " +
SCHEMA_VERSION);
}
LOGGER.info("Installed sdrtrunk schema version " + SCHEMA_VERSION + " in " +
mConfiguration.getDescription() + (version > 0 ? " (upgraded from version " + version + ")" : ""));
}
}
}
/**
* Statements that bring the tables from the version argument up to the current version.
*/
private List<String> getUpgradeStatements(int fromVersion)
{
List<String> statements = new ArrayList<>();
if(fromVersion < 1)
{
statements.addAll(CallRepository.getCreateStatements(mConfiguration.type().getDialect(), mConfiguration.schema()));
}
//Version 2: talkgroups patched into patch group calls
if(fromVersion < 2)
{
statements.addAll(CallRepository.getPatchedTalkgroupCreateStatements(mConfiguration.schema()));
}
return statements;
}
/**
* Installed schema version, or 0 when nothing is installed.
*/
private int getVersion(Connection connection) throws SQLException
{
try(Statement statement = connection.createStatement();
ResultSet rs = statement.executeQuery("SELECT MAX(version) FROM " + mConfiguration.schema() + "." +
SCHEMA_INFO_TABLE))
{
return rs.next() ? rs.getInt(1) : 0;
}
}
/**
* Drops the schema with all of its tables and then installs an empty sdrtrunk schema.
*/
public void clear() throws SQLException
{
try(Connection connection = getConnection(); Statement statement = connection.createStatement())
{
statement.execute(mConfiguration.type().getDialect().getDropSchemaStatement(mConfiguration.schema()));
}
install();
}
/**
* Suggests an unused schema name derived from the configured schema name (e.g. sdrtrunk_2).
*/
public String suggestSchemaName() throws SQLException
{
try(Connection connection = getConnection())
{
String base = mConfiguration.schema();
for(int x = 2; x < 1000; x++)
{
String candidate = base + "_" + x;
if(candidate.length() <= 63 && getSchemaStatus(connection, candidate) == SchemaStatus.MISSING)
{
return candidate;
}
}
}
return mConfiguration.schema() + "_new";
}
/**
* Indicates if the named schema exists in this database.
*/
public boolean schemaExists(String schema) throws SQLException
{
try(Connection connection = getConnection())
{
return getSchemaStatus(connection, schema) != SchemaStatus.MISSING;
}
}
@Override
public void close()
{
if(!mDataSource.isClosed())
{
mDataSource.close();
}
}
}

View File

@@ -1,158 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database;
import java.nio.file.Path;
import java.util.Objects;
import java.util.regex.Pattern;
/**
* Connection settings for a call database.
*
* @param type of database engine
* @param host name or address of a network database server (ignored for H2)
* @param port of the network database server (ignored for H2)
* @param database name to connect to (PostgreSQL only)
* @param schema name that holds the sdrtrunk tables
* @param user name for a network database server
* @param password for a network database server
*/
public record DatabaseConfiguration(DatabaseType type, String host, int port, String database, String schema,
String user, String password)
{
public static final String DEFAULT_SCHEMA = "sdrtrunk";
/**
* Schema names are restricted to unquoted SQL identifiers so that they can be used in statements without quoting
* and so that they mean the same thing across all engines (H2 upper-cases unquoted names, the others don't).
*/
private static final Pattern SCHEMA_PATTERN = Pattern.compile("[a-z][a-z0-9_]{0,62}");
public DatabaseConfiguration
{
Objects.requireNonNull(type, "type");
host = host == null ? "" : host.trim();
database = database == null ? "" : database.trim();
schema = schema == null || schema.isBlank() ? DEFAULT_SCHEMA : schema.trim().toLowerCase();
user = user == null ? "" : user;
password = password == null ? "" : password;
}
/**
* Default configuration: the built-in H2 database with the default schema.
*/
public static DatabaseConfiguration getDefault()
{
return new DatabaseConfiguration(DatabaseType.H2, "", 0, "", DEFAULT_SCHEMA, "", "");
}
/**
* Copy of this configuration with a different schema name.
*/
public DatabaseConfiguration withSchema(String schemaName)
{
return new DatabaseConfiguration(type, host, port, database, schemaName, user, password);
}
/**
* Indicates if the schema name is a valid, unquoted identifier.
*/
public static boolean isValidSchemaName(String schema)
{
return schema != null && SCHEMA_PATTERN.matcher(schema).matches();
}
/**
* Validates this configuration.
* @return null if valid, or a description of the problem.
*/
public String validate()
{
if(!isValidSchemaName(schema))
{
return "Schema name must start with a letter and contain only lower case letters, digits and underscores " +
"(max 63 characters)";
}
if(type.isNetwork())
{
if(host.isEmpty())
{
return "Host is required";
}
if(port <= 0 || port > 65535)
{
return "Port must be in the range 1 - 65535";
}
if(user.isEmpty())
{
return "User name is required";
}
}
if(type.requiresDatabaseName() && database.isEmpty())
{
return "Database name is required";
}
return null;
}
/**
* JDBC URL for this configuration.
* @param databaseDirectory for the built-in H2 database files
*/
public String getJdbcUrl(Path databaseDirectory)
{
return type.getDialect().getJdbcUrl(this, databaseDirectory);
}
/**
* Short description for the user, without the password.
*/
public String getDescription()
{
return switch(type)
{
case H2 -> type + " - schema [" + schema + "]";
case MARIADB -> type + " " + user + "@" + host + ":" + port + " - schema [" + schema + "]";
case POSTGRESQL -> type + " " + user + "@" + host + ":" + port + "/" + database + " - schema [" +
schema + "]";
};
}
/**
* Indicates if this configuration refers to the same database and schema as the other configuration (ignoring
* credentials).
*/
public boolean isSameLocation(DatabaseConfiguration other)
{
return other != null && type == other.type && schema.equals(other.schema) &&
(!type.isNetwork() || (host.equalsIgnoreCase(other.host) && port == other.port &&
database.equals(other.database)));
}
@Override
public String toString()
{
return getDescription();
}
}

View File

@@ -1,45 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database;
/**
* Call database status change notification
*
* @param type of event
* @param configuration of the current database
* @param errorMessage for an ERROR event, otherwise null
*/
public record DatabaseEvent(Type type, DatabaseConfiguration configuration, String errorMessage)
{
public enum Type
{
/**
* Database opened, or a different database was selected
*/
CONNECTED,
/**
* Database couldn't be opened or the connection was lost
*/
ERROR,
/**
* Stored calls changed outside of the live call updates, for example by an age-off rule
*/
CALLS_CHANGED
}
}

View File

@@ -1,718 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database;
import io.github.dsheirer.database.ageoff.AgeOffManager;
import io.github.dsheirer.database.call.CallRecord;
import io.github.dsheirer.database.call.ICallRepository;
import io.github.dsheirer.database.call.CallSearchCriteria;
import io.github.dsheirer.database.call.CallState;
import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.sample.Broadcaster;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.controller.NamingThreadFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.file.Path;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
/**
* Manages the call database: opens the selected database at startup, writes call records in the background, runs the
* age-off rules and switches between databases (with optional transfer of the existing calls).
*
* All writes, the age-off rules and database switches run on a single database thread, so they never overlap.
* Searches run on a separate thread so that a long write doesn't block the user interface.
*
* Call recording doesn't depend on the database: when the database is unavailable, call updates are held in memory
* (newest update per call) and written when the database becomes available again.
*/
public class DatabaseManager
{
private static final Logger LOGGER = LoggerFactory.getLogger(DatabaseManager.class);
private static final long FLUSH_INTERVAL_MS = 250;
private static final long RETRY_INTERVAL_MS = 30_000;
private static final int MAX_PENDING_CALLS = 20_000;
private static final int TRANSFER_PAGE_SIZE = 1000;
private final UserPreferences mUserPreferences;
private final ScheduledExecutorService mDatabaseExecutor =
Executors.newSingleThreadScheduledExecutor(new NamingThreadFactory("sdrtrunk call database"));
private final ExecutorService mQueryExecutor =
Executors.newSingleThreadExecutor(new NamingThreadFactory("sdrtrunk call database query"));
private final Broadcaster<DatabaseEvent> mEventBroadcaster = new Broadcaster<>();
private final Broadcaster<CallRecord> mSavedCallBroadcaster = new Broadcaster<>();
private final Map<CallHandle,CallRecord> mPendingCalls = new LinkedHashMap<>();
private final AgeOffManager mAgeOffManager;
private volatile CallDatabase mDatabase;
private volatile String mErrorMessage;
private volatile int mGeneration = 1;
private long mNextRetry;
private ScheduledFuture<?> mFlushFuture;
/**
* Constructs an instance
* @param userPreferences for the database selection and age-off rules
*/
public DatabaseManager(UserPreferences userPreferences)
{
mUserPreferences = userPreferences;
mAgeOffManager = new AgeOffManager(this, userPreferences);
}
/**
* Opens the selected database, installs or upgrades the sdrtrunk schema and starts the background writer.
* Blocks until the database is open (or failed to open) so that calls from the first channels are stored.
*/
public void start()
{
try
{
mDatabaseExecutor.submit(this::openConfiguredDatabase).get(30, TimeUnit.SECONDS);
}
catch(Exception e)
{
LOGGER.error("Timeout or error while opening the call database", e);
}
mFlushFuture = mDatabaseExecutor.scheduleWithFixedDelay(this::flush, FLUSH_INTERVAL_MS, FLUSH_INTERVAL_MS,
TimeUnit.MILLISECONDS);
mAgeOffManager.start(mDatabaseExecutor);
}
/**
* Writes any remaining call updates and closes the database.
*/
public void stop()
{
mAgeOffManager.stop();
if(mFlushFuture != null)
{
mFlushFuture.cancel(false);
}
try
{
mDatabaseExecutor.submit(() -> {
flush();
closeDatabase();
}).get(15, TimeUnit.SECONDS);
}
catch(Exception e)
{
LOGGER.error("Error while closing the call database", e);
}
mDatabaseExecutor.shutdownNow();
mQueryExecutor.shutdownNow();
}
/**
* Directory for the built-in database files
*/
public Path getDatabaseDirectory()
{
return mUserPreferences.getDirectoryPreference().getDirectoryDatabase();
}
/**
* Opens the database from the user preferences. Database thread only.
*/
private void openConfiguredDatabase()
{
DatabaseConfiguration configuration = mUserPreferences.getDatabasePreference().getDatabaseConfiguration();
try
{
CallDatabase database = new CallDatabase(configuration, getDatabaseDirectory());
try
{
database.install();
try(Connection connection = database.getConnection())
{
int interrupted = database.getCallRepository().markInterrupted(connection);
if(interrupted > 0)
{
LOGGER.info("Marked " + interrupted + " calls from the previous session as interrupted");
}
}
}
catch(SQLException se)
{
database.close();
throw se;
}
mDatabase = database;
mErrorMessage = null;
LOGGER.info("Call database opened: " + configuration.getDescription());
broadcast(DatabaseEvent.Type.CONNECTED);
}
catch(SQLException se)
{
mErrorMessage = se.getMessage();
mNextRetry = System.currentTimeMillis() + RETRY_INTERVAL_MS;
LOGGER.error("Unable to open the call database [" + configuration.getDescription() + "] - " +
se.getMessage());
broadcast(DatabaseEvent.Type.ERROR);
}
}
private void closeDatabase()
{
CallDatabase database = mDatabase;
mDatabase = null;
if(database != null)
{
database.close();
}
}
/**
* Currently open database, or null if the database isn't available.
*/
public CallDatabase getDatabase()
{
return mDatabase;
}
/**
* Current database configuration (from the preferences).
*/
public DatabaseConfiguration getConfiguration()
{
CallDatabase database = mDatabase;
return database != null ? database.getConfiguration() :
mUserPreferences.getDatabasePreference().getDatabaseConfiguration();
}
/**
* Indicates if the database is open
*/
public boolean isConnected()
{
return mDatabase != null;
}
/**
* Description of the last error opening the database, or null.
*/
public String getErrorMessage()
{
return mErrorMessage;
}
/**
* Creates a handle that tracks the database row of one call across updates.
*/
public CallHandle createHandle()
{
return new CallHandle();
}
/**
* Queues a snapshot of the call for insertion (first time) or update. Only the newest snapshot for each call is
* written, so this can be invoked as often as the call changes.
* @param handle for the call
* @param snapshot of the call that is not modified after this call
*/
public void save(CallHandle handle, CallRecord snapshot)
{
synchronized(mPendingCalls)
{
mPendingCalls.put(handle, snapshot);
//Bound memory use if the database is unavailable for a long time. Drop the oldest completed calls first.
if(mPendingCalls.size() > MAX_PENDING_CALLS)
{
Iterator<Map.Entry<CallHandle,CallRecord>> it = mPendingCalls.entrySet().iterator();
while(it.hasNext() && mPendingCalls.size() > MAX_PENDING_CALLS)
{
if(!it.next().getValue().isActive())
{
it.remove();
}
}
LOGGER.warn("Call database is unavailable - discarding the oldest pending call updates");
}
}
}
/**
* Writes the pending call updates. Database thread only.
*/
private void flush()
{
CallDatabase database = mDatabase;
if(database == null)
{
//Retry opening the database periodically
if(mErrorMessage != null && System.currentTimeMillis() > mNextRetry)
{
openConfiguredDatabase();
database = mDatabase;
}
if(database == null)
{
return;
}
}
List<Map.Entry<CallHandle,CallRecord>> batch;
synchronized(mPendingCalls)
{
if(mPendingCalls.isEmpty())
{
return;
}
batch = new ArrayList<>(mPendingCalls.entrySet());
mPendingCalls.clear();
}
ICallRepository repository = database.getCallRepository();
int written = 0;
try(Connection connection = database.getConnection())
{
for(Map.Entry<CallHandle,CallRecord> entry: batch)
{
CallHandle handle = entry.getKey();
CallRecord call = entry.getValue();
if(handle.mGeneration == mGeneration && handle.mId > 0)
{
call.setId(handle.mId);
if(repository.update(connection, call))
{
written++;
mSavedCallBroadcaster.broadcast(call);
continue;
}
}
//New call, a call that started before a database switch, or a row removed by an age-off rule.
call.setId(0);
handle.mId = repository.insert(connection, call);
handle.mGeneration = mGeneration;
written++;
mSavedCallBroadcaster.broadcast(call);
}
}
catch(SQLException se)
{
LOGGER.error("Error writing call updates to the database - " + se.getMessage());
//Put back the updates that weren't written, unless a newer update arrived in the meantime
synchronized(mPendingCalls)
{
Map<CallHandle,CallRecord> newer = new LinkedHashMap<>(mPendingCalls);
mPendingCalls.clear();
for(int x = written; x < batch.size(); x++)
{
mPendingCalls.put(batch.get(x).getKey(), batch.get(x).getValue());
}
mPendingCalls.putAll(newer);
}
if(!isReachable(database))
{
LOGGER.error("Call database connection lost - will retry");
closeDatabase();
mErrorMessage = se.getMessage();
mNextRetry = System.currentTimeMillis() + RETRY_INTERVAL_MS;
broadcast(DatabaseEvent.Type.ERROR);
}
}
}
private static boolean isReachable(CallDatabase database)
{
try(Connection connection = database.getConnection())
{
return connection.isValid(5);
}
catch(SQLException se)
{
return false;
}
}
/**
* Searches the calls table on the query thread.
*/
public CompletableFuture<SearchResult> search(CallSearchCriteria criteria, int offset, int limit)
{
return CompletableFuture.supplyAsync(() -> {
CallDatabase database = mDatabase;
if(database == null)
{
throw new IllegalStateException("Call database is not available" +
(mErrorMessage != null ? ": " + mErrorMessage : ""));
}
try(Connection connection = database.getConnection())
{
List<CallRecord> calls = database.getCallRepository().search(connection, criteria, offset, limit);
long total = database.getCallRepository().count(connection, criteria);
return new SearchResult(calls, total);
}
catch(SQLException se)
{
throw new IllegalStateException(se.getMessage(), se);
}
}, mQueryExecutor);
}
/**
* Search results
* @param calls in the requested page
* @param total count of matching calls
*/
public record SearchResult(List<CallRecord> calls, long total) {}
/**
* Connects to the database configuration and reports the state of its schema. Runs on the query thread.
*/
public CompletableFuture<ProbeResult> probe(DatabaseConfiguration configuration)
{
return CompletableFuture.supplyAsync(() -> {
try(CallDatabase database = new CallDatabase(configuration, getDatabaseDirectory()))
{
SchemaStatus status = database.getSchemaStatus();
long count = status == SchemaStatus.SDRTRUNK ? database.getCallCount() : 0;
String suggestion = status == SchemaStatus.MISSING ? configuration.schema() :
database.suggestSchemaName();
return new ProbeResult(status, count, suggestion);
}
catch(SQLException se)
{
throw new IllegalStateException(se.getMessage(), se);
}
}, mQueryExecutor);
}
/**
* Result of probing a database configuration
* @param status of the configured schema
* @param callCount in the configured schema
* @param suggestedSchema an unused schema name, for the create separate schema option
*/
public record ProbeResult(SchemaStatus status, long callCount, String suggestedSchema) {}
/**
* Checks whether a schema exists in the database of the configuration. Runs on the query thread.
*/
public CompletableFuture<Boolean> schemaExists(DatabaseConfiguration configuration, String schema)
{
return CompletableFuture.supplyAsync(() -> {
try(CallDatabase database = new CallDatabase(configuration, getDatabaseDirectory()))
{
return database.schemaExists(schema);
}
catch(SQLException se)
{
throw new IllegalStateException(se.getMessage(), se);
}
}, mQueryExecutor);
}
/**
* How to treat an existing sdrtrunk schema in the database being switched to
*/
public enum ExistingSchemaOption
{
/**
* Keep the existing calls and add to them
*/
APPEND,
/**
* Remove the existing calls and start empty
*/
CLEAR
}
/**
* Switches to a different database.
*
* @param target configuration, including the schema name to use (a new name for the create separate schema option)
* @param schemaOption for an existing sdrtrunk schema in the target
* @param transfer true to copy the calls from the current database to the target
* @param progress receives status text while the switch runs (on the database thread)
* @return future that completes when the switch is complete, or completes exceptionally on error, in which case
* the current database remains selected
*/
public CompletableFuture<SwitchResult> switchDatabase(DatabaseConfiguration target,
ExistingSchemaOption schemaOption, boolean transfer,
Consumer<String> progress)
{
CompletableFuture<SwitchResult> future = new CompletableFuture<>();
mDatabaseExecutor.execute(() -> {
CallDatabase targetDatabase = null;
try
{
progress.accept("Connecting to " + target.getDescription());
targetDatabase = new CallDatabase(target, getDatabaseDirectory());
SchemaStatus status = targetDatabase.getSchemaStatus();
if(status == SchemaStatus.SDRTRUNK && schemaOption == ExistingSchemaOption.CLEAR)
{
progress.accept("Clearing schema [" + target.schema() + "]");
targetDatabase.clear();
}
else
{
progress.accept("Installing schema [" + target.schema() + "]");
targetDatabase.install();
}
long transferred = 0;
long skipped = 0;
CallDatabase current = mDatabase;
if(transfer && current != null && !current.getConfiguration().isSameLocation(target))
{
//Write pending updates first so that they are included in the transfer
flush();
long[] counts = transfer(current, targetDatabase, progress);
transferred = counts[0];
skipped = counts[1];
}
try(Connection connection = targetDatabase.getConnection())
{
targetDatabase.getCallRepository().markInterrupted(connection);
}
//Write remaining pending updates to the current database before switching, so that active calls
//continue in the new database
flush();
CallDatabase previous = mDatabase;
mDatabase = targetDatabase;
mGeneration++;
mErrorMessage = null;
mUserPreferences.getDatabasePreference().setDatabaseConfiguration(target);
if(previous != null)
{
//Calls in progress continue in the new database, so remove them from the previous database
try(Connection connection = previous.getConnection())
{
previous.getCallRepository().deleteActive(connection);
}
catch(SQLException se)
{
LOGGER.warn("Unable to remove calls in progress from the previous database - " +
se.getMessage());
}
previous.close();
}
LOGGER.info("Switched call database to " + target.getDescription() + " - transferred " +
transferred + " calls" + (skipped > 0 ? ", skipped " + skipped + " existing calls" : ""));
broadcast(DatabaseEvent.Type.CONNECTED);
future.complete(new SwitchResult(transferred, skipped));
}
catch(Exception e)
{
LOGGER.error("Error switching the call database to " + target.getDescription(), e);
if(targetDatabase != null && targetDatabase != mDatabase)
{
targetDatabase.close();
}
future.completeExceptionally(e);
}
});
return future;
}
/**
* Result of a database switch
* @param transferred count of calls copied to the new database
* @param skipped count of calls that already existed in the new database
*/
public record SwitchResult(long transferred, long skipped) {}
/**
* Copies the calls from the source to the target database, skipping calls in progress (they are written to the
* target after the switch) and calls that already exist in the target.
* @return transferred and skipped counts
*/
private long[] transfer(CallDatabase source, CallDatabase target, Consumer<String> progress) throws SQLException
{
ICallRepository sourceRepository = source.getCallRepository();
ICallRepository targetRepository = target.getCallRepository();
long transferred = 0;
long skipped = 0;
try(Connection sourceConnection = source.getConnection(); Connection targetConnection = target.getConnection())
{
long total = sourceRepository.count(sourceConnection);
Set<String> existing = targetRepository.count(targetConnection) > 0 ?
targetRepository.getTransferKeys(targetConnection) : Collections.emptySet();
boolean autoCommit = targetConnection.getAutoCommit();
targetConnection.setAutoCommit(false);
try
{
long afterId = 0;
List<CallRecord> page = sourceRepository.readPage(sourceConnection, afterId, TRANSFER_PAGE_SIZE);
while(!page.isEmpty())
{
List<CallRecord> toInsert = new ArrayList<>();
for(CallRecord call: page)
{
if(call.getCallState() == CallState.ACTIVE || existing.contains(call.getTransferKey()))
{
skipped++;
}
else
{
toInsert.add(call);
}
}
if(!toInsert.isEmpty())
{
targetRepository.insertBatch(targetConnection, toInsert);
targetConnection.commit();
transferred += toInsert.size();
}
afterId = page.getLast().getId();
progress.accept("Transferring calls: " + (transferred + skipped) + " of " + total);
page = sourceRepository.readPage(sourceConnection, afterId, TRANSFER_PAGE_SIZE);
}
}
catch(SQLException se)
{
targetConnection.rollback();
throw se;
}
finally
{
targetConnection.setAutoCommit(autoCommit);
}
}
return new long[]{transferred, skipped};
}
/**
* Age-off rule manager
*/
public AgeOffManager getAgeOffManager()
{
return mAgeOffManager;
}
/**
* Runs the task on the database thread.
*/
public CompletableFuture<Void> runOnDatabaseThread(Runnable runnable)
{
return CompletableFuture.runAsync(runnable, mDatabaseExecutor);
}
/**
* Notifies listeners that the stored calls changed outside of the normal call updates (age-off, switch, delete).
*/
public void notifyCallsChanged()
{
broadcast(DatabaseEvent.Type.CALLS_CHANGED);
}
private void broadcast(DatabaseEvent.Type type)
{
mEventBroadcaster.broadcast(new DatabaseEvent(type, getConfiguration(), mErrorMessage));
}
/**
* Registers the listener to receive database events (on the database thread)
*/
public void addListener(Listener<DatabaseEvent> listener)
{
mEventBroadcaster.addListener(listener);
}
public void removeListener(Listener<DatabaseEvent> listener)
{
mEventBroadcaster.removeListener(listener);
}
/**
* Registers the listener to receive each call after it is written to the database, with its row id assigned.
* Notified on the database thread.
*/
public void addCallSavedListener(Listener<CallRecord> listener)
{
mSavedCallBroadcaster.addListener(listener);
}
public void removeCallSavedListener(Listener<CallRecord> listener)
{
mSavedCallBroadcaster.removeListener(listener);
}
/**
* Tracks the database row of a call. Accessed only on the database thread.
*/
public static class CallHandle
{
private long mId;
private int mGeneration;
}
}

View File

@@ -1,81 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database;
import io.github.dsheirer.database.dialect.H2Dialect;
import io.github.dsheirer.database.dialect.IDatabaseDialect;
import io.github.dsheirer.database.dialect.MariaDBDialect;
import io.github.dsheirer.database.dialect.PostgreSQLDialect;
/**
* Supported call database engines. The engine differences are implemented by each type's {@link IDatabaseDialect}.
*/
public enum DatabaseType
{
H2("Built-in (H2)", new H2Dialect()),
MARIADB("MariaDB", new MariaDBDialect()),
POSTGRESQL("PostgreSQL", new PostgreSQLDialect());
private final String mLabel;
private final IDatabaseDialect mDialect;
DatabaseType(String label, IDatabaseDialect dialect)
{
mLabel = label;
mDialect = dialect;
}
/**
* SQL dialect and connection settings for this engine
*/
public IDatabaseDialect getDialect()
{
return mDialect;
}
/**
* Indicates if this is a network database server that needs a host, port and credentials.
*/
public boolean isNetwork()
{
return mDialect.isNetwork();
}
/**
* Indicates if this engine needs a database name in addition to the schema name.
*/
public boolean requiresDatabaseName()
{
return mDialect.requiresDatabaseName();
}
/**
* Default TCP port for a network database, or 0 for the embedded database.
*/
public int getDefaultPort()
{
return mDialect.getDefaultPort();
}
@Override
public String toString()
{
return mLabel;
}
}

View File

@@ -1,38 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database;
/**
* State of a schema in a database
*/
public enum SchemaStatus
{
/**
* Schema doesn't exist
*/
MISSING,
/**
* Schema exists but doesn't have sdrtrunk tables
*/
EMPTY,
/**
* Schema has sdrtrunk tables
*/
SDRTRUNK
}

View File

@@ -1,41 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.ageoff;
/**
* What an age-off rule removes
*/
public enum AgeOffAction
{
DELETE_CALL_AND_RECORDING("Delete the call and its recording"),
DELETE_RECORDING_ONLY("Delete the recording, keep the call");
private final String mLabel;
AgeOffAction(String label)
{
mLabel = label;
}
@Override
public String toString()
{
return mLabel;
}
}

View File

@@ -1,329 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.ageoff;
import io.github.dsheirer.database.CallDatabase;
import io.github.dsheirer.database.DatabaseManager;
import io.github.dsheirer.database.call.CallRecord;
import io.github.dsheirer.database.call.ICallRepository;
import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.preference.database.DatabasePreference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
/**
* Applies the call audio age-off rules:
* <ul>
* <li>Retention rule: deletes duplicate calls, and Do Not Monitor calls that no alias marked for recording, with
* their recordings, after the retention period (default 1 hour).</li>
* <li>Age rule: removes calls older than a number of days.</li>
* <li>Size rule: removes the oldest recordings when the total size of the recordings exceeds a limit.</li>
* </ul>
* The age and size rules either delete the call row and its recording file, or delete only the recording file and
* keep the call row.
*
* The rules run a minute after startup, then every 5 minutes, and when the user requests it. Calls in progress are
* never removed. Only recordings tracked in the call database are considered.
*/
public class AgeOffManager
{
private static final Logger LOGGER = LoggerFactory.getLogger(AgeOffManager.class);
private static final long INITIAL_DELAY_SECONDS = 60;
private static final long INTERVAL_SECONDS = 300;
private static final int PAGE_SIZE = 500;
public static final long BYTES_PER_MB = 1024L * 1024L;
private final DatabaseManager mDatabaseManager;
private final DatabasePreference mPreference;
private ScheduledFuture<?> mScheduledFuture;
/**
* Constructs an instance
*/
public AgeOffManager(DatabaseManager databaseManager, UserPreferences userPreferences)
{
mDatabaseManager = databaseManager;
mPreference = userPreferences.getDatabasePreference();
}
/**
* Schedules the periodic age-off on the database thread.
*/
public void start(ScheduledExecutorService databaseExecutor)
{
if(mScheduledFuture == null)
{
mScheduledFuture = databaseExecutor.scheduleWithFixedDelay(this::runSafely, INITIAL_DELAY_SECONDS,
INTERVAL_SECONDS, TimeUnit.SECONDS);
}
}
public void stop()
{
if(mScheduledFuture != null)
{
mScheduledFuture.cancel(false);
mScheduledFuture = null;
}
}
/**
* Runs the enabled rules now.
* @return future with the results
*/
public CompletableFuture<AgeOffResult> runNow()
{
CompletableFuture<AgeOffResult> future = new CompletableFuture<>();
mDatabaseManager.runOnDatabaseThread(() -> {
try
{
future.complete(run());
}
catch(Exception e)
{
future.completeExceptionally(e);
}
});
return future;
}
private void runSafely()
{
try
{
run();
}
catch(Exception e)
{
LOGGER.error("Error applying the call age-off rules", e);
}
}
/**
* Applies the enabled rules. Database thread only.
*/
private AgeOffResult run() throws SQLException
{
CallDatabase database = mDatabaseManager.getDatabase();
RetentionPeriod retention = mPreference.getDuplicateDoNotMonitorRetention();
if(database == null || (!retention.isEnabled() && !mPreference.isAgeRuleEnabled() &&
!mPreference.isSizeRuleEnabled()))
{
return new AgeOffResult(0, 0, 0);
}
AgeOffResult result = new AgeOffResult(0, 0, 0);
try(Connection connection = database.getConnection())
{
ICallRepository repository = database.getCallRepository();
if(retention.isEnabled())
{
long cutoff = System.currentTimeMillis() - retention.getMilliseconds();
result = result.add(applyRetentionRule(connection, repository, cutoff));
}
if(mPreference.isAgeRuleEnabled())
{
long cutoff = System.currentTimeMillis() - TimeUnit.DAYS.toMillis(mPreference.getAgeRuleDays());
result = result.add(applyAgeRule(connection, repository, cutoff, mPreference.getAgeRuleAction()));
}
if(mPreference.isSizeRuleEnabled())
{
long limit = mPreference.getSizeRuleLimitMB() * BYTES_PER_MB;
result = result.add(applySizeRule(connection, repository, limit, mPreference.getSizeRuleAction()));
}
}
if(result.calls() > 0 || result.recordings() > 0)
{
LOGGER.info("Call age-off removed " + result.calls() + " calls and " + result.recordings() +
" recordings (" + (result.bytes() / BYTES_PER_MB) + " MB)");
mDatabaseManager.notifyCallsChanged();
}
return result;
}
/**
* Deletes duplicate calls and Do Not Monitor calls (without an alias record option) that started before the
* cutoff time, with their recordings.
*/
static AgeOffResult applyRetentionRule(Connection connection, ICallRepository repository, long cutoff)
throws SQLException
{
AgeOffResult result = new AgeOffResult(0, 0, 0);
List<CallRecord> page = repository.getDuplicateAndDoNotMonitorCalls(connection, cutoff, PAGE_SIZE);
while(!page.isEmpty())
{
result = result.add(remove(connection, repository, page, AgeOffAction.DELETE_CALL_AND_RECORDING));
page = repository.getDuplicateAndDoNotMonitorCalls(connection, cutoff, PAGE_SIZE);
}
return result;
}
/**
* Removes the calls (or recordings) of calls that started before the cutoff time.
*/
static AgeOffResult applyAgeRule(Connection connection, ICallRepository repository, long cutoff,
AgeOffAction action) throws SQLException
{
AgeOffResult result = new AgeOffResult(0, 0, 0);
List<CallRecord> page = action == AgeOffAction.DELETE_CALL_AND_RECORDING ?
repository.getCallsStartedBefore(connection, cutoff, PAGE_SIZE) :
repository.getRecordedCalls(connection, cutoff, PAGE_SIZE);
while(!page.isEmpty())
{
result = result.add(remove(connection, repository, page, action));
page = action == AgeOffAction.DELETE_CALL_AND_RECORDING ?
repository.getCallsStartedBefore(connection, cutoff, PAGE_SIZE) :
repository.getRecordedCalls(connection, cutoff, PAGE_SIZE);
}
return result;
}
/**
* Removes the oldest recordings until the total size of the recordings is at or below the limit.
*/
static AgeOffResult applySizeRule(Connection connection, ICallRepository repository, long limitBytes,
AgeOffAction action) throws SQLException
{
AgeOffResult result = new AgeOffResult(0, 0, 0);
long total = repository.getRecordedFileSize(connection);
while(total > limitBytes)
{
List<CallRecord> page = repository.getRecordedCalls(connection, 0, PAGE_SIZE);
if(page.isEmpty())
{
break;
}
List<CallRecord> toRemove = new ArrayList<>();
for(CallRecord call: page)
{
if(total <= limitBytes)
{
break;
}
toRemove.add(call);
total -= call.getFileSize();
}
result = result.add(remove(connection, repository, toRemove, action));
}
return result;
}
/**
* Deletes the recording files of the calls and then deletes the call rows or marks their recordings deleted.
*/
private static AgeOffResult remove(Connection connection, ICallRepository repository, List<CallRecord> calls,
AgeOffAction action) throws SQLException
{
long bytes = 0;
int recordings = 0;
List<Long> ids = new ArrayList<>();
for(CallRecord call: calls)
{
ids.add(call.getId());
if(call.getFilePath() != null && deleteRecording(call.getFilePath()))
{
recordings++;
bytes += call.getFileSize();
}
}
if(action == AgeOffAction.DELETE_CALL_AND_RECORDING)
{
repository.delete(connection, ids);
return new AgeOffResult(ids.size(), recordings, bytes);
}
repository.markRecordingsDeleted(connection, ids);
return new AgeOffResult(0, recordings, bytes);
}
/**
* Deletes the audio recording file. Only audio files (.mp3, .wav) are deleted.
* @return true if the file was deleted
*/
static boolean deleteRecording(String filePath)
{
String lower = filePath.toLowerCase(Locale.ROOT);
if(!lower.endsWith(".mp3") && !lower.endsWith(".wav"))
{
LOGGER.warn("Age-off skipped deleting non-audio file [" + filePath + "]");
return false;
}
try
{
return Files.deleteIfExists(Path.of(filePath));
}
catch(IOException | RuntimeException e)
{
LOGGER.warn("Age-off unable to delete recording [" + filePath + "] - " + e.getMessage());
return false;
}
}
/**
* Age-off results
* @param calls deleted
* @param recordings deleted
* @param bytes of recordings deleted
*/
public record AgeOffResult(long calls, long recordings, long bytes)
{
public AgeOffResult add(AgeOffResult other)
{
return new AgeOffResult(calls + other.calls, recordings + other.recordings, bytes + other.bytes);
}
}
}

View File

@@ -1,71 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.ageoff;
import java.util.concurrent.TimeUnit;
/**
* How long duplicate and Do Not Monitor calls (and their recordings) are kept before they are deleted
*/
public enum RetentionPeriod
{
MINUTES_30("30 minutes", TimeUnit.MINUTES.toMillis(30)),
HOUR_1("1 hour", TimeUnit.HOURS.toMillis(1)),
HOURS_2("2 hours", TimeUnit.HOURS.toMillis(2)),
HOURS_4("4 hours", TimeUnit.HOURS.toMillis(4)),
HOURS_8("8 hours", TimeUnit.HOURS.toMillis(8)),
HOURS_12("12 hours", TimeUnit.HOURS.toMillis(12)),
DAY_1("1 day", TimeUnit.DAYS.toMillis(1)),
DAYS_2("2 days", TimeUnit.DAYS.toMillis(2)),
DAYS_7("7 days", TimeUnit.DAYS.toMillis(7)),
NEVER("Never delete", 0);
public static final RetentionPeriod DEFAULT = HOUR_1;
private final String mLabel;
private final long mMilliseconds;
RetentionPeriod(String label, long milliseconds)
{
mLabel = label;
mMilliseconds = milliseconds;
}
/**
* Retention time in milliseconds, or 0 for never
*/
public long getMilliseconds()
{
return mMilliseconds;
}
/**
* Indicates if calls are deleted after this period
*/
public boolean isEnabled()
{
return this != NEVER;
}
@Override
public String toString()
{
return mLabel;
}
}

View File

@@ -1,568 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
import io.github.dsheirer.protocol.Protocol;
import java.util.List;
/**
* A call audio event as stored in the calls table.
*
* Instances are mutable while they are being built, but a record that has been handed to the database writer or to
* the user interface is a snapshot that is never changed afterwards. Use {@link #copy()} to create a new snapshot.
*/
public class CallRecord
{
public static final String FORM_TALKGROUP = "TALKGROUP";
public static final String FORM_PATCH_GROUP = "PATCH_GROUP";
public static final String FORM_RADIO = "RADIO";
private long mId;
private long mCallKey;
private long mStartTime;
private long mEndTime;
private CallState mCallState = CallState.ACTIVE;
private String mProtocol;
private String mSystem;
private String mSite;
private String mChannel;
private long mFrequency;
private int mTimeslot;
private String mToId;
private Long mToValue;
private String mToForm;
private String mToFullyQualified;
private String mFromId;
private Long mFromValue;
private String mFromForm;
private String mFromFullyQualified;
private String mAliasList;
private List<PatchedTalkgroup> mPatchedTalkgroups = List.of();
private String mTalkerAlias;
private boolean mEncrypted;
private boolean mDuplicate;
private int mPriority;
private boolean mAliasRecord;
private String mRecordFormat;
private String mFilePath;
private long mFileSize;
private RecordingState mRecordingState = RecordingState.NONE;
/**
* Creates a copy (snapshot) of this record.
*/
public CallRecord copy()
{
CallRecord copy = new CallRecord();
copy.mId = mId;
copy.mCallKey = mCallKey;
copy.mStartTime = mStartTime;
copy.mEndTime = mEndTime;
copy.mCallState = mCallState;
copy.mProtocol = mProtocol;
copy.mSystem = mSystem;
copy.mSite = mSite;
copy.mChannel = mChannel;
copy.mFrequency = mFrequency;
copy.mTimeslot = mTimeslot;
copy.mToId = mToId;
copy.mToValue = mToValue;
copy.mToForm = mToForm;
copy.mToFullyQualified = mToFullyQualified;
copy.mFromId = mFromId;
copy.mFromValue = mFromValue;
copy.mFromForm = mFromForm;
copy.mFromFullyQualified = mFromFullyQualified;
copy.mAliasList = mAliasList;
copy.mPatchedTalkgroups = mPatchedTalkgroups;
copy.mTalkerAlias = mTalkerAlias;
copy.mEncrypted = mEncrypted;
copy.mDuplicate = mDuplicate;
copy.mPriority = mPriority;
copy.mAliasRecord = mAliasRecord;
copy.mRecordFormat = mRecordFormat;
copy.mFilePath = mFilePath;
copy.mFileSize = mFileSize;
copy.mRecordingState = mRecordingState;
return copy;
}
/**
* Database row identifier, or 0 if this call hasn't been inserted yet.
*/
public long getId()
{
return mId;
}
public void setId(long id)
{
mId = id;
}
/**
* In-memory key that identifies a live call across snapshots, or 0 for records loaded from the database.
*/
public long getCallKey()
{
return mCallKey;
}
public void setCallKey(long callKey)
{
mCallKey = callKey;
}
/**
* Call start time, milliseconds since epoch
*/
public long getStartTime()
{
return mStartTime;
}
public void setStartTime(long startTime)
{
mStartTime = startTime;
}
/**
* Call end time, milliseconds since epoch, or 0 while the call is active.
*/
public long getEndTime()
{
return mEndTime;
}
public void setEndTime(long endTime)
{
mEndTime = endTime;
}
/**
* Call duration in milliseconds. For an active call this is the elapsed time up to now.
*/
public long getDuration()
{
if(mEndTime > 0)
{
return Math.max(0, mEndTime - mStartTime);
}
return isActive() ? Math.max(0, System.currentTimeMillis() - mStartTime) : 0;
}
public CallState getCallState()
{
return mCallState;
}
public void setCallState(CallState callState)
{
mCallState = callState;
}
/**
* Indicates if the call is in progress.
*/
public boolean isActive()
{
return mCallState == CallState.ACTIVE;
}
/**
* Protocol enumeration entry name (e.g. APCO25)
*/
public String getProtocol()
{
return mProtocol;
}
public void setProtocol(String protocol)
{
mProtocol = protocol;
}
/**
* Protocol, or UNKNOWN if the stored value isn't recognized.
*/
public Protocol getProtocolValue()
{
if(mProtocol != null)
{
try
{
return Protocol.valueOf(mProtocol);
}
catch(IllegalArgumentException iae)
{
//Fall through
}
}
return Protocol.UNKNOWN;
}
public String getSystem()
{
return mSystem;
}
public void setSystem(String system)
{
mSystem = system;
}
public String getSite()
{
return mSite;
}
public void setSite(String site)
{
mSite = site;
}
public String getChannel()
{
return mChannel;
}
public void setChannel(String channel)
{
mChannel = channel;
}
/**
* Channel frequency in Hertz, or 0 if unknown.
*/
public long getFrequency()
{
return mFrequency;
}
public void setFrequency(long frequency)
{
mFrequency = frequency;
}
public int getTimeslot()
{
return mTimeslot;
}
public void setTimeslot(int timeslot)
{
mTimeslot = timeslot;
}
/**
* Formatted TO identifier (talkgroup, patch group or radio)
*/
public String getToId()
{
return mToId;
}
public void setToId(String toId)
{
mToId = toId;
}
/**
* Numeric TO identifier value, or null. For a patch group, this is the patch group talkgroup.
*/
public Long getToValue()
{
return mToValue;
}
public void setToValue(Long toValue)
{
mToValue = toValue;
}
/**
* Indicates if the TO identifier of this call is a talkgroup or patch group that can be used as a hold talkgroup.
*/
public boolean hasTalkgroup()
{
return mToValue != null && mToValue > 0 && isToTalkgroup();
}
/**
* Indicates if the TO identifier is a talkgroup or patch group (as opposed to a radio, for a private call).
*/
public boolean isToTalkgroup()
{
return FORM_TALKGROUP.equals(mToForm) || FORM_PATCH_GROUP.equals(mToForm);
}
/**
* Call type (group, patch, private or telephone), derived from the TO and FROM identifier forms.
*/
public CallType getCallType()
{
return CallType.from(mToForm, mFromForm);
}
/**
* Identifier form (Form enumeration name, e.g. TALKGROUP, PATCH_GROUP or RADIO) of the TO identifier, or null.
*/
public String getToForm()
{
return mToForm;
}
public void setToForm(String toForm)
{
mToForm = toForm;
}
/**
* Fully qualified address (wacn.system.id) of a fully qualified (roaming) TO talkgroup, or null.
*/
public String getToFullyQualified()
{
return mToFullyQualified;
}
public void setToFullyQualified(String toFullyQualified)
{
mToFullyQualified = toFullyQualified;
}
/**
* Identifier form (Form enumeration name, e.g. RADIO) of the FROM identifier, or null.
*/
public String getFromForm()
{
return mFromForm;
}
public void setFromForm(String fromForm)
{
mFromForm = fromForm;
}
/**
* Indicates if the FROM identifier is a radio
*/
public boolean isFromRadio()
{
return FORM_RADIO.equals(mFromForm);
}
/**
* Fully qualified address (wacn.system.id) of a fully qualified (roaming) FROM radio, or null.
*/
public String getFromFullyQualified()
{
return mFromFullyQualified;
}
public void setFromFullyQualified(String fromFullyQualified)
{
mFromFullyQualified = fromFullyQualified;
}
/**
* Talkgroups that are patched into the TO patch group of the call, or an empty list. Searching for a talkgroup
* finds the calls that it participated in through a patch.
*/
public List<PatchedTalkgroup> getPatchedTalkgroups()
{
return mPatchedTalkgroups;
}
public void setPatchedTalkgroups(List<PatchedTalkgroup> patchedTalkgroups)
{
mPatchedTalkgroups = patchedTalkgroups == null ? List.of() : List.copyOf(patchedTalkgroups);
}
/**
* Name of the alias list that was assigned to the channel for this call, or null. Aliases for the TO and FROM
* identifiers are looked up in the current version of this alias list when the call is displayed.
*/
public String getAliasList()
{
return mAliasList;
}
public void setAliasList(String aliasList)
{
mAliasList = aliasList;
}
public String getFromId()
{
return mFromId;
}
public void setFromId(String fromId)
{
mFromId = fromId;
}
public Long getFromValue()
{
return mFromValue;
}
public void setFromValue(Long fromValue)
{
mFromValue = fromValue;
}
public String getTalkerAlias()
{
return mTalkerAlias;
}
public void setTalkerAlias(String talkerAlias)
{
mTalkerAlias = talkerAlias;
}
public boolean isEncrypted()
{
return mEncrypted;
}
public void setEncrypted(boolean encrypted)
{
mEncrypted = encrypted;
}
public boolean isDuplicate()
{
return mDuplicate;
}
public void setDuplicate(boolean duplicate)
{
mDuplicate = duplicate;
}
/**
* Alias playback priority
*/
public int getPriority()
{
return mPriority;
}
public void setPriority(int priority)
{
mPriority = priority;
}
/**
* Indicates if an alias of the call has the record option, as opposed to the call being recorded only because
* all calls are recorded. Do Not Monitor calls with an alias record option are kept by the retention rule.
*/
public boolean isAliasRecord()
{
return mAliasRecord;
}
public void setAliasRecord(boolean aliasRecord)
{
mAliasRecord = aliasRecord;
}
/**
* Recording format (MP3 or WAVE), or null when the call isn't recorded.
*/
public String getRecordFormat()
{
return mRecordFormat;
}
public void setRecordFormat(String recordFormat)
{
mRecordFormat = recordFormat;
}
/**
* Absolute path of the audio recording file, or null.
*/
public String getFilePath()
{
return mFilePath;
}
public void setFilePath(String filePath)
{
mFilePath = filePath;
}
/**
* Recording file size in bytes
*/
public long getFileSize()
{
return mFileSize;
}
public void setFileSize(long fileSize)
{
mFileSize = fileSize;
}
public RecordingState getRecordingState()
{
return mRecordingState;
}
public void setRecordingState(RecordingState recordingState)
{
mRecordingState = recordingState;
}
/**
* Indicates if this call has a completed audio recording that can be played.
*/
public boolean isPlayable()
{
return mRecordingState == RecordingState.RECORDED && mFilePath != null;
}
/**
* Key used to detect a call that already exists in a target database during an append transfer. The recording
* file path identifies a call uniquely. Calls without a recording use their start time, channel and TO.
*/
public String getTransferKey()
{
if(mFilePath != null && !mFilePath.isEmpty())
{
return "F:" + mFilePath;
}
return "C:" + mStartTime + "|" + mChannel + "|" + mTimeslot + "|" + mToId + "|" + mFromId;
}
@Override
public String toString()
{
return "Call " + mId + " " + mProtocol + " TO:" + mToId + " FROM:" + mFromId + " " + mCallState + " " +
mRecordingState + (mFilePath != null ? " " + mFilePath : "");
}
}

View File

@@ -1,909 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
import io.github.dsheirer.alias.id.priority.Priority;
import io.github.dsheirer.database.dialect.IDatabaseDialect;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
/**
* JDBC implementation of the calls table, using SQL that is portable across all supported database engines. All
* methods take a connection from the caller and qualify the table name with the schema, so this class has no state
* other than the schema name.
*/
public class CallRepository implements ICallRepository
{
public static final String TABLE = "calls";
public static final String PATCHED_TABLE = "patched_talkgroups";
/**
* Columns in insert/select order, excluding the generated id.
*/
private static final String COLUMNS = "start_time, end_time, duration_ms, call_state, protocol, system_name, " +
"site_name, channel_name, frequency, timeslot, to_id, to_value, to_form, to_fq, from_id, from_value, " +
"from_form, from_fq, alias_list, talker_alias, encrypted, duplicate_call, priority, alias_record, " +
"record_format, file_path, file_size, recording_state";
private static final int COLUMN_COUNT = 28;
/**
* Maximum stored lengths of the text columns, so that a long alias or channel name can't fail an insert.
*/
private static final int LENGTH_SHORT = 32;
private static final int LENGTH_ID = 64;
private static final int LENGTH_NAME = 255;
private static final int LENGTH_PATH = 1024;
private final String mSchema;
private final String mTable;
private final String mPatchedTable;
/**
* Constructs an instance
* @param schema that holds the calls table
*/
public CallRepository(String schema)
{
mSchema = schema;
mTable = schema + "." + TABLE;
mPatchedTable = schema + "." + PATCHED_TABLE;
}
/**
* Statements that create the calls table and its indexes.
*/
public static List<String> getCreateStatements(IDatabaseDialect dialect, String schema)
{
String table = schema + "." + TABLE;
List<String> statements = new ArrayList<>();
statements.add("CREATE TABLE IF NOT EXISTS " + table + " (" +
"id " + dialect.getIdentityColumn() + ", " +
"start_time BIGINT NOT NULL, " +
"end_time BIGINT NOT NULL, " +
"duration_ms BIGINT NOT NULL, " +
"call_state VARCHAR(" + LENGTH_SHORT + ") NOT NULL, " +
"protocol VARCHAR(" + LENGTH_SHORT + "), " +
"system_name VARCHAR(" + LENGTH_NAME + "), " +
"site_name VARCHAR(" + LENGTH_NAME + "), " +
"channel_name VARCHAR(" + LENGTH_NAME + "), " +
"frequency BIGINT NOT NULL, " +
"timeslot INT NOT NULL, " +
"to_id VARCHAR(" + LENGTH_ID + "), " +
"to_value BIGINT, " +
"to_form VARCHAR(" + LENGTH_SHORT + "), " +
"to_fq VARCHAR(" + LENGTH_ID + "), " +
"from_id VARCHAR(" + LENGTH_ID + "), " +
"from_value BIGINT, " +
"from_form VARCHAR(" + LENGTH_SHORT + "), " +
"from_fq VARCHAR(" + LENGTH_ID + "), " +
"alias_list VARCHAR(" + LENGTH_NAME + "), " +
"talker_alias VARCHAR(" + LENGTH_NAME + "), " +
"encrypted BOOLEAN NOT NULL, " +
"duplicate_call BOOLEAN NOT NULL, " +
"priority INT NOT NULL, " +
"alias_record BOOLEAN NOT NULL, " +
"record_format VARCHAR(" + LENGTH_SHORT + "), " +
"file_path VARCHAR(" + LENGTH_PATH + "), " +
"file_size BIGINT NOT NULL, " +
"recording_state VARCHAR(" + LENGTH_SHORT + ") NOT NULL)");
//Index names are scoped to the schema (H2, PostgreSQL) or the table (MariaDB), so prefix them with the table
statements.add("CREATE INDEX IF NOT EXISTS calls_start_time_idx ON " + table + " (start_time)");
statements.add("CREATE INDEX IF NOT EXISTS calls_to_value_idx ON " + table + " (to_value)");
statements.add("CREATE INDEX IF NOT EXISTS calls_from_value_idx ON " + table + " (from_value)");
statements.add("CREATE INDEX IF NOT EXISTS calls_recording_state_idx ON " + table +
" (recording_state, start_time)");
return statements;
}
/**
* Statements that create the patched talkgroups table (schema version 2). Rows are deleted with their call.
*/
public static List<String> getPatchedTalkgroupCreateStatements(String schema)
{
String table = schema + "." + PATCHED_TABLE;
List<String> statements = new ArrayList<>();
statements.add("CREATE TABLE IF NOT EXISTS " + table + " (" +
"call_id BIGINT NOT NULL REFERENCES " + schema + "." + TABLE + "(id) ON DELETE CASCADE, " +
"talkgroup BIGINT NOT NULL, " +
"fq VARCHAR(" + LENGTH_ID + "))");
statements.add("CREATE INDEX IF NOT EXISTS patched_talkgroups_call_idx ON " + table + " (call_id)");
statements.add("CREATE INDEX IF NOT EXISTS patched_talkgroups_talkgroup_idx ON " + table + " (talkgroup)");
return statements;
}
/**
* Inserts the call and assigns the generated row id to the call.
* @return generated row id
*/
@Override
public long insert(Connection connection, CallRecord call) throws SQLException
{
String sql = "INSERT INTO " + mTable + " (" + COLUMNS + ") VALUES (" + "?, ".repeat(COLUMN_COUNT - 1) + "?)";
try(PreparedStatement statement = connection.prepareStatement(sql, new String[]{"id"}))
{
bind(statement, call);
statement.executeUpdate();
try(ResultSet keys = statement.getGeneratedKeys())
{
if(keys.next())
{
long id = keys.getLong(1);
call.setId(id);
insertPatchedTalkgroups(connection, id, call.getPatchedTalkgroups());
return id;
}
}
}
throw new SQLException("Database didn't return a generated id for the inserted call");
}
/**
* Inserts the calls in a single batch without retrieving the generated ids.
*/
@Override
public void insertBatch(Connection connection, List<CallRecord> calls) throws SQLException
{
String sql = "INSERT INTO " + mTable + " (" + COLUMNS + ") VALUES (" + "?, ".repeat(COLUMN_COUNT - 1) + "?)";
List<CallRecord> patched = new ArrayList<>();
try(PreparedStatement statement = connection.prepareStatement(sql))
{
for(CallRecord call: calls)
{
//Calls with patched talkgroups need their generated id for the patched talkgroup rows
if(!call.getPatchedTalkgroups().isEmpty())
{
patched.add(call);
continue;
}
bind(statement, call);
statement.addBatch();
}
statement.executeBatch();
}
for(CallRecord call: patched)
{
insert(connection, call);
}
}
/**
* Inserts the patched talkgroup rows of a call
*/
private void insertPatchedTalkgroups(Connection connection, long callId, List<PatchedTalkgroup> talkgroups)
throws SQLException
{
if(talkgroups.isEmpty())
{
return;
}
try(PreparedStatement statement = connection.prepareStatement("INSERT INTO " + mPatchedTable +
" (call_id, talkgroup, fq) VALUES (?, ?, ?)"))
{
for(PatchedTalkgroup talkgroup: talkgroups)
{
statement.setLong(1, callId);
statement.setLong(2, talkgroup.value());
setString(statement, 3, talkgroup.fullyQualified(), LENGTH_ID);
statement.addBatch();
}
statement.executeBatch();
}
}
/**
* Replaces the patched talkgroup rows of a call
*/
private void replacePatchedTalkgroups(Connection connection, long callId, List<PatchedTalkgroup> talkgroups)
throws SQLException
{
try(PreparedStatement statement = connection.prepareStatement("DELETE FROM " + mPatchedTable +
" WHERE call_id = ?"))
{
statement.setLong(1, callId);
statement.executeUpdate();
}
insertPatchedTalkgroups(connection, callId, talkgroups);
}
/**
* Loads the patched talkgroups of the patch group calls in the list.
*/
private void loadPatchedTalkgroups(Connection connection, List<CallRecord> calls) throws SQLException
{
Map<Long,CallRecord> patchCalls = new HashMap<>();
for(CallRecord call: calls)
{
if(CallRecord.FORM_PATCH_GROUP.equals(call.getToForm()))
{
patchCalls.put(call.getId(), call);
}
}
if(patchCalls.isEmpty())
{
return;
}
Map<Long,List<PatchedTalkgroup>> talkgroups = new HashMap<>();
String placeholders = String.join(", ", Collections.nCopies(patchCalls.size(), "?"));
try(PreparedStatement statement = connection.prepareStatement("SELECT call_id, talkgroup, fq FROM " +
mPatchedTable + " WHERE call_id IN (" + placeholders + ") ORDER BY call_id, talkgroup"))
{
int index = 1;
for(Long id: patchCalls.keySet())
{
statement.setLong(index++, id);
}
try(ResultSet rs = statement.executeQuery())
{
while(rs.next())
{
talkgroups.computeIfAbsent(rs.getLong(1), id -> new ArrayList<>())
.add(new PatchedTalkgroup(rs.getLong(2), rs.getString(3)));
}
}
}
for(Map.Entry<Long,List<PatchedTalkgroup>> entry: talkgroups.entrySet())
{
patchCalls.get(entry.getKey()).setPatchedTalkgroups(entry.getValue());
}
}
/**
* Updates all columns of the existing call row.
* @return true if the row exists and was updated
*/
@Override
public boolean update(Connection connection, CallRecord call) throws SQLException
{
String assignments = String.join(" = ?, ", COLUMNS.split(", ")) + " = ?";
String sql = "UPDATE " + mTable + " SET " + assignments + " WHERE id = ?";
try(PreparedStatement statement = connection.prepareStatement(sql))
{
bind(statement, call);
statement.setLong(COLUMN_COUNT + 1, call.getId());
if(statement.executeUpdate() == 0)
{
return false;
}
}
if(CallRecord.FORM_PATCH_GROUP.equals(call.getToForm()) || !call.getPatchedTalkgroups().isEmpty())
{
replacePatchedTalkgroups(connection, call.getId(), call.getPatchedTalkgroups());
}
return true;
}
/**
* Binds the call column values to statement parameters 1 - COLUMN_COUNT.
*/
private static void bind(PreparedStatement statement, CallRecord call) throws SQLException
{
int index = 1;
statement.setLong(index++, call.getStartTime());
statement.setLong(index++, call.getEndTime());
statement.setLong(index++, call.getEndTime() > 0 ? call.getDuration() : 0);
statement.setString(index++, call.getCallState().name());
setString(statement, index++, call.getProtocol(), LENGTH_SHORT);
setString(statement, index++, call.getSystem(), LENGTH_NAME);
setString(statement, index++, call.getSite(), LENGTH_NAME);
setString(statement, index++, call.getChannel(), LENGTH_NAME);
statement.setLong(index++, call.getFrequency());
statement.setInt(index++, call.getTimeslot());
setString(statement, index++, call.getToId(), LENGTH_ID);
setLong(statement, index++, call.getToValue());
setString(statement, index++, call.getToForm(), LENGTH_SHORT);
setString(statement, index++, call.getToFullyQualified(), LENGTH_ID);
setString(statement, index++, call.getFromId(), LENGTH_ID);
setLong(statement, index++, call.getFromValue());
setString(statement, index++, call.getFromForm(), LENGTH_SHORT);
setString(statement, index++, call.getFromFullyQualified(), LENGTH_ID);
setString(statement, index++, call.getAliasList(), LENGTH_NAME);
setString(statement, index++, call.getTalkerAlias(), LENGTH_NAME);
statement.setBoolean(index++, call.isEncrypted());
statement.setBoolean(index++, call.isDuplicate());
statement.setInt(index++, call.getPriority());
statement.setBoolean(index++, call.isAliasRecord());
setString(statement, index++, call.getRecordFormat(), LENGTH_SHORT);
setString(statement, index++, call.getFilePath(), LENGTH_PATH);
statement.setLong(index++, call.getFileSize());
statement.setString(index, call.getRecordingState().name());
}
private static void setString(PreparedStatement statement, int index, String value, int maxLength)
throws SQLException
{
if(value == null)
{
statement.setNull(index, Types.VARCHAR);
}
else
{
statement.setString(index, value.length() > maxLength ? value.substring(0, maxLength) : value);
}
}
private static void setLong(PreparedStatement statement, int index, Long value) throws SQLException
{
if(value == null)
{
statement.setNull(index, Types.BIGINT);
}
else
{
statement.setLong(index, value);
}
}
/**
* Creates a call record from the current result set row.
*/
private static CallRecord read(ResultSet rs) throws SQLException
{
CallRecord call = new CallRecord();
call.setId(rs.getLong("id"));
call.setStartTime(rs.getLong("start_time"));
call.setEndTime(rs.getLong("end_time"));
call.setCallState(CallState.fromValue(rs.getString("call_state")));
call.setProtocol(rs.getString("protocol"));
call.setSystem(rs.getString("system_name"));
call.setSite(rs.getString("site_name"));
call.setChannel(rs.getString("channel_name"));
call.setFrequency(rs.getLong("frequency"));
call.setTimeslot(rs.getInt("timeslot"));
call.setToId(rs.getString("to_id"));
call.setToValue(getLong(rs, "to_value"));
call.setToForm(rs.getString("to_form"));
call.setToFullyQualified(rs.getString("to_fq"));
call.setFromId(rs.getString("from_id"));
call.setFromValue(getLong(rs, "from_value"));
call.setFromForm(rs.getString("from_form"));
call.setFromFullyQualified(rs.getString("from_fq"));
call.setAliasList(rs.getString("alias_list"));
call.setTalkerAlias(rs.getString("talker_alias"));
call.setEncrypted(rs.getBoolean("encrypted"));
call.setDuplicate(rs.getBoolean("duplicate_call"));
call.setPriority(rs.getInt("priority"));
call.setAliasRecord(rs.getBoolean("alias_record"));
call.setRecordFormat(rs.getString("record_format"));
call.setFilePath(rs.getString("file_path"));
call.setFileSize(rs.getLong("file_size"));
call.setRecordingState(RecordingState.fromValue(rs.getString("recording_state")));
return call;
}
private static Long getLong(ResultSet rs, String column) throws SQLException
{
long value = rs.getLong(column);
return rs.wasNull() ? null : value;
}
/**
* Marks any calls left in the active state, by a previous session that didn't shut down cleanly, as interrupted.
* Recordings that were being written are left as recorded if the file has data.
* @return count of calls updated
*/
@Override
public int markInterrupted(Connection connection) throws SQLException
{
try(Statement statement = connection.createStatement())
{
int count = statement.executeUpdate("UPDATE " + mTable + " SET call_state = '" +
CallState.INTERRUPTED.name() + "' WHERE call_state = '" + CallState.ACTIVE.name() + "'");
statement.executeUpdate("UPDATE " + mTable + " SET recording_state = '" + RecordingState.RECORDED.name() +
"' WHERE recording_state = '" + RecordingState.RECORDING.name() + "' AND file_path IS NOT NULL");
return count;
}
}
@Override
public int deleteActive(Connection connection) throws SQLException
{
try(PreparedStatement statement = connection.prepareStatement("DELETE FROM " + mTable +
" WHERE call_state = ?"))
{
statement.setString(1, CallState.ACTIVE.name());
return statement.executeUpdate();
}
}
/**
* Searches for calls matching the criteria, newest first.
* @param criteria to filter by
* @param offset of the first row to return
* @param limit maximum rows to return
*/
@Override
public List<CallRecord> search(Connection connection, CallSearchCriteria criteria, int offset, int limit)
throws SQLException
{
List<Object> parameters = new ArrayList<>();
String where = getWhereClause(criteria, parameters);
String sql = "SELECT id, " + COLUMNS + " FROM " + mTable + " c" + where +
" ORDER BY start_time DESC, id DESC LIMIT ? OFFSET ?";
parameters.add(limit);
parameters.add(offset);
List<CallRecord> calls = new ArrayList<>();
try(PreparedStatement statement = connection.prepareStatement(sql))
{
bindParameters(statement, parameters);
try(ResultSet rs = statement.executeQuery())
{
while(rs.next())
{
calls.add(read(rs));
}
}
}
loadPatchedTalkgroups(connection, calls);
return calls;
}
/**
* Count of calls matching the criteria
*/
@Override
public long count(Connection connection, CallSearchCriteria criteria) throws SQLException
{
List<Object> parameters = new ArrayList<>();
String sql = "SELECT COUNT(*) FROM " + mTable + " c" + getWhereClause(criteria, parameters);
try(PreparedStatement statement = connection.prepareStatement(sql))
{
bindParameters(statement, parameters);
try(ResultSet rs = statement.executeQuery())
{
return rs.next() ? rs.getLong(1) : 0;
}
}
}
/**
* Builds the WHERE clause (with a leading space) for the criteria and adds the parameter values to the list.
*/
private String getWhereClause(CallSearchCriteria criteria, List<Object> parameters)
{
List<String> clauses = new ArrayList<>();
if(!criteria.to().isEmpty())
{
clauses.add(getIdentifierClause("to", criteria.to(), "to_form IN ('" + CallRecord.FORM_TALKGROUP + "', '" +
CallRecord.FORM_PATCH_GROUP + "')", mPatchedTable, parameters));
}
if(!criteria.from().isEmpty())
{
clauses.add(getIdentifierClause("from", criteria.from(), "from_form = '" + CallRecord.FORM_RADIO + "'",
null, parameters));
}
if(!criteria.talkerAlias().isEmpty())
{
clauses.add("LOWER(talker_alias) LIKE ? ESCAPE '!'");
parameters.add(getLikePattern(criteria.talkerAlias()));
}
if(criteria.protocol() != null)
{
clauses.add("protocol = ?");
parameters.add(criteria.protocol().name());
}
if(criteria.callType() != null)
{
clauses.add(criteria.callType().getWhereClause());
}
if(!criteria.system().isEmpty())
{
clauses.add("LOWER(system_name) LIKE ? ESCAPE '!'");
parameters.add(getLikePattern(criteria.system()));
}
if(criteria.startTime() > 0)
{
clauses.add("start_time >= ?");
parameters.add(criteria.startTime());
}
if(criteria.endTime() > 0)
{
clauses.add("start_time <= ?");
parameters.add(criteria.endTime());
}
return clauses.isEmpty() ? "" : " WHERE " + String.join(" AND ", clauses);
}
/**
* WHERE clause for a TO or FROM identifier filter.
* @param prefix of the identifier columns (to or from)
* @param filter to apply
* @param formClause that restricts an alias filter to the identifier forms that the alias identifiers apply to
* @param patchedTable to also match the talkgroups patched into a patch group call (TO filter), or null
* @param parameters to add the parameter values to
*/
private static String getIdentifierClause(String prefix, IdentifierFilter filter, String formClause,
String patchedTable, List<Object> parameters)
{
String valueColumn = prefix + "_value";
String fqColumn = prefix + "_fq";
String patched = patchedTable != null ? "EXISTS (SELECT 1 FROM " + patchedTable + " p WHERE p.call_id = c.id AND " :
null;
if(filter.isAlias())
{
List<String> matches = new ArrayList<>();
List<Object> matchParameters = new ArrayList<>();
for(IdentifierFilter.ValueRange range: filter.ranges())
{
matches.add("(" + fqColumn + " IS NULL AND protocol = ? AND " + valueColumn + " BETWEEN ? AND ?)");
matchParameters.add(range.protocol().name());
matchParameters.add((long)range.min());
matchParameters.add((long)range.max());
if(patched != null)
{
matches.add("(protocol = ? AND " + patched + "p.fq IS NULL AND p.talkgroup BETWEEN ? AND ?))");
matchParameters.add(range.protocol().name());
matchParameters.add((long)range.min());
matchParameters.add((long)range.max());
}
}
for(IdentifierFilter.FullyQualifiedAddress address: filter.fullyQualified())
{
matches.add("(protocol = ? AND " + fqColumn + " = ?)");
matchParameters.add(address.protocol().name());
matchParameters.add(address.address());
if(patched != null)
{
matches.add("(protocol = ? AND " + patched + "p.fq = ?))");
matchParameters.add(address.protocol().name());
matchParameters.add(address.address());
}
}
if(matches.isEmpty())
{
return "1 = 0";
}
parameters.add(filter.aliasList() != null ? filter.aliasList().toLowerCase(Locale.ROOT) : "");
parameters.addAll(matchParameters);
return "(LOWER(alias_list) = ? AND " + formClause + " AND (" + String.join(" OR ", matches) + "))";
}
Long value = CallSearchCriteria.parseValue(filter.text());
parameters.add(getLikePattern(filter.text()));
if(value != null)
{
parameters.add(value);
if(patched != null)
{
parameters.add(value);
return "(LOWER(" + prefix + "_id) LIKE ? ESCAPE '!' OR " + valueColumn + " = ? OR " + patched +
"p.talkgroup = ?))";
}
return "(LOWER(" + prefix + "_id) LIKE ? ESCAPE '!' OR " + valueColumn + " = ?)";
}
return "LOWER(" + prefix + "_id) LIKE ? ESCAPE '!'";
}
/**
* Case-insensitive 'contains' LIKE pattern with the LIKE wildcard characters escaped.
*/
static String getLikePattern(String text)
{
String escaped = text.toLowerCase(Locale.ROOT).replace("!", "!!").replace("%", "!%").replace("_", "!_");
return "%" + escaped + "%";
}
private static void bindParameters(PreparedStatement statement, List<Object> parameters) throws SQLException
{
for(int x = 0; x < parameters.size(); x++)
{
Object parameter = parameters.get(x);
if(parameter instanceof String s)
{
statement.setString(x + 1, s);
}
else if(parameter instanceof Integer i)
{
statement.setInt(x + 1, i);
}
else if(parameter instanceof Long l)
{
statement.setLong(x + 1, l);
}
else
{
throw new IllegalArgumentException("Unsupported parameter type: " + parameter);
}
}
}
/**
* Reads a page of calls in id order, for transferring calls between databases.
* @param afterId only return calls with an id greater than this value
* @param limit maximum number of calls
*/
@Override
public List<CallRecord> readPage(Connection connection, long afterId, int limit) throws SQLException
{
String sql = "SELECT id, " + COLUMNS + " FROM " + mTable + " WHERE id > ? ORDER BY id LIMIT ?";
List<CallRecord> calls = new ArrayList<>();
try(PreparedStatement statement = connection.prepareStatement(sql))
{
statement.setLong(1, afterId);
statement.setInt(2, limit);
try(ResultSet rs = statement.executeQuery())
{
while(rs.next())
{
calls.add(read(rs));
}
}
}
loadPatchedTalkgroups(connection, calls);
return calls;
}
/**
* Total number of call rows
*/
@Override
public long count(Connection connection) throws SQLException
{
return count(connection, CallSearchCriteria.all());
}
/**
* Transfer keys (see {@link CallRecord#getTransferKey()}) of all calls in the table, for skipping calls that
* already exist when appending.
*/
@Override
public Set<String> getTransferKeys(Connection connection) throws SQLException
{
Set<String> keys = new HashSet<>();
long afterId = 0;
List<CallRecord> page = readPage(connection, afterId, 5000);
while(!page.isEmpty())
{
for(CallRecord call: page)
{
keys.add(call.getTransferKey());
}
afterId = page.getLast().getId();
page = readPage(connection, afterId, 5000);
}
return keys;
}
/**
* Calls with a recording, oldest first, for age-off processing.
* @param startedBefore only include calls that started before this time, or 0 for any time
* @param limit maximum number of calls
*/
@Override
public List<CallRecord> getRecordedCalls(Connection connection, long startedBefore, int limit) throws SQLException
{
String sql = "SELECT id, " + COLUMNS + " FROM " + mTable + " WHERE recording_state = ?" +
(startedBefore > 0 ? " AND start_time < ?" : "") + " ORDER BY start_time, id LIMIT ?";
List<CallRecord> calls = new ArrayList<>();
try(PreparedStatement statement = connection.prepareStatement(sql))
{
int index = 1;
statement.setString(index++, RecordingState.RECORDED.name());
if(startedBefore > 0)
{
statement.setLong(index++, startedBefore);
}
statement.setInt(index, limit);
try(ResultSet rs = statement.executeQuery())
{
while(rs.next())
{
calls.add(read(rs));
}
}
}
return calls;
}
/**
* Completed calls that started before the time, oldest first, for age-off processing.
*/
@Override
public List<CallRecord> getCallsStartedBefore(Connection connection, long startedBefore, int limit)
throws SQLException
{
String sql = "SELECT id, " + COLUMNS + " FROM " + mTable + " WHERE start_time < ? AND call_state <> ? " +
"ORDER BY start_time, id LIMIT ?";
List<CallRecord> calls = new ArrayList<>();
try(PreparedStatement statement = connection.prepareStatement(sql))
{
statement.setLong(1, startedBefore);
statement.setString(2, CallState.ACTIVE.name());
statement.setInt(3, limit);
try(ResultSet rs = statement.executeQuery())
{
while(rs.next())
{
calls.add(read(rs));
}
}
}
return calls;
}
@Override
public List<CallRecord> getDuplicateAndDoNotMonitorCalls(Connection connection, long startedBefore, int limit)
throws SQLException
{
String sql = "SELECT id, " + COLUMNS + " FROM " + mTable + " WHERE start_time < ? AND call_state <> ? AND " +
"(duplicate_call = ? OR (priority <= ? AND alias_record = ?)) ORDER BY start_time, id LIMIT ?";
List<CallRecord> calls = new ArrayList<>();
try(PreparedStatement statement = connection.prepareStatement(sql))
{
statement.setLong(1, startedBefore);
statement.setString(2, CallState.ACTIVE.name());
statement.setBoolean(3, true);
statement.setInt(4, Priority.DO_NOT_MONITOR);
statement.setBoolean(5, false);
statement.setInt(6, limit);
try(ResultSet rs = statement.executeQuery())
{
while(rs.next())
{
calls.add(read(rs));
}
}
}
return calls;
}
/**
* Total size of all recordings that are still available.
*/
@Override
public long getRecordedFileSize(Connection connection) throws SQLException
{
try(PreparedStatement statement = connection.prepareStatement("SELECT SUM(file_size) FROM " + mTable +
" WHERE recording_state = ?"))
{
statement.setString(1, RecordingState.RECORDED.name());
try(ResultSet rs = statement.executeQuery())
{
return rs.next() ? rs.getLong(1) : 0;
}
}
}
/**
* Deletes the call rows
*/
@Override
public void delete(Connection connection, List<Long> ids) throws SQLException
{
try(PreparedStatement statement = connection.prepareStatement("DELETE FROM " + mTable + " WHERE id = ?"))
{
for(Long id: ids)
{
statement.setLong(1, id);
statement.addBatch();
}
statement.executeBatch();
}
}
/**
* Clears the recording file of the calls and marks the recordings as deleted, keeping the call rows.
*/
@Override
public void markRecordingsDeleted(Connection connection, List<Long> ids) throws SQLException
{
try(PreparedStatement statement = connection.prepareStatement("UPDATE " + mTable + " SET recording_state = ?, " +
"file_path = NULL, file_size = 0 WHERE id = ?"))
{
for(Long id: ids)
{
statement.setString(1, RecordingState.DELETED.name());
statement.setLong(2, id);
statement.addBatch();
}
statement.executeBatch();
}
}
/**
* Schema name
*/
@Override
public String getSchema()
{
return mSchema;
}
}

View File

@@ -1,151 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
import io.github.dsheirer.protocol.Protocol;
import java.util.List;
import java.util.Locale;
/**
* Search filter for the calls table. Empty text fields, empty identifier filters and null values don't filter.
*
* @param to filter for the TO identifier (talkgroup, patch group or radio): typed text or a selected talkgroup alias
* @param from filter for the FROM identifier (radio): typed text or a selected radio alias
* @param talkerAlias text matched against the decoded talker alias
* @param protocol to match or null
* @param callType to match or null
* @param system text matched against the system name
* @param startTime earliest call start time (ms since epoch) or 0
* @param endTime latest call start time (ms since epoch) or 0
*/
public record CallSearchCriteria(IdentifierFilter to, IdentifierFilter from, String talkerAlias, Protocol protocol,
CallType callType, String system, long startTime, long endTime)
{
/**
* Criteria without a call type filter
*/
public CallSearchCriteria(IdentifierFilter to, IdentifierFilter from, String talkerAlias, Protocol protocol,
String system, long startTime, long endTime)
{
this(to, from, talkerAlias, protocol, null, system, startTime, endTime);
}
public CallSearchCriteria
{
to = to == null ? IdentifierFilter.none() : to;
from = from == null ? IdentifierFilter.none() : from;
talkerAlias = clean(talkerAlias);
system = clean(system);
}
/**
* Criteria that match every call
*/
public static CallSearchCriteria all()
{
return new CallSearchCriteria(null, null, null, null, null, 0, 0);
}
private static String clean(String value)
{
return value == null ? "" : value.trim();
}
/**
* Indicates if these criteria match every call.
*/
public boolean isEmpty()
{
return to.isEmpty() && from.isEmpty() && talkerAlias.isEmpty() && system.isEmpty() && protocol == null &&
callType == null && startTime == 0 && endTime == 0;
}
/**
* Parses the text as a decimal identifier value, or null if it isn't a number.
*/
static Long parseValue(String text)
{
if(text == null || text.isEmpty() || text.length() > 18)
{
return null;
}
for(int x = 0; x < text.length(); x++)
{
if(!Character.isDigit(text.charAt(x)))
{
return null;
}
}
return Long.parseLong(text);
}
/**
* Evaluates the criteria against a call in memory, using the same rules as the database query. This is used to
* decide whether a live call belongs in the currently displayed search results.
*/
public boolean matches(CallRecord call)
{
if(!to.isEmpty() && !to.matches(call, call.getToId(), call.getToValue(), call.getToFullyQualified(),
call.isToTalkgroup(), call.getPatchedTalkgroups()))
{
return false;
}
if(!from.isEmpty() && !from.matches(call, call.getFromId(), call.getFromValue(),
call.getFromFullyQualified(), call.isFromRadio(), List.of()))
{
return false;
}
if(!talkerAlias.isEmpty() && !contains(call.getTalkerAlias(), talkerAlias))
{
return false;
}
if(protocol != null && !protocol.name().equals(call.getProtocol()))
{
return false;
}
if(callType != null && call.getCallType() != callType)
{
return false;
}
if(!system.isEmpty() && !contains(call.getSystem(), system))
{
return false;
}
if(startTime > 0 && call.getStartTime() < startTime)
{
return false;
}
return endTime <= 0 || call.getStartTime() <= endTime;
}
private static boolean contains(String value, String text)
{
return value != null && value.toLowerCase(Locale.ROOT).contains(text.toLowerCase(Locale.ROOT));
}
}

View File

@@ -1,71 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
/**
* Call life-cycle state
*/
public enum CallState
{
/**
* Call is in progress
*/
ACTIVE("Active"),
/**
* Call completed normally
*/
COMPLETE("Complete"),
/**
* Call was in progress when sdrtrunk stopped (e.g. a crash) and never completed
*/
INTERRUPTED("Interrupted");
private final String mLabel;
CallState(String label)
{
mLabel = label;
}
@Override
public String toString()
{
return mLabel;
}
/**
* Parses the stored value, defaulting to COMPLETE for unrecognized values.
*/
public static CallState fromValue(String value)
{
if(value != null)
{
try
{
return CallState.valueOf(value);
}
catch(IllegalArgumentException iae)
{
//Fall through
}
}
return COMPLETE;
}
}

View File

@@ -1,120 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
/**
* Type of call, derived from the stored TO and FROM identifier forms.
*/
public enum CallType
{
/**
* Call to a talkgroup
*/
GROUP("Group"),
/**
* Call to a patch group (talkgroups patched together)
*/
PATCH("Patch"),
/**
* Private (individual) call from one radio to another radio
*/
PRIVATE("Private"),
/**
* Telephone interconnect call between a radio and a telephone
*/
TELEPHONE("Telephone"),
/**
* Call without a TO identifier that identifies the call type (e.g. conventional analog)
*/
UNKNOWN("");
private static final String FORM_TELEPHONE_NUMBER = "TELEPHONE_NUMBER";
private final String mLabel;
CallType(String label)
{
mLabel = label;
}
/**
* Call type for the TO and FROM identifier forms (Form enumeration names).
*/
public static CallType from(String toForm, String fromForm)
{
if(CallRecord.FORM_PATCH_GROUP.equals(toForm))
{
return PATCH;
}
if(CallRecord.FORM_TALKGROUP.equals(toForm))
{
return GROUP;
}
if(FORM_TELEPHONE_NUMBER.equals(toForm) || FORM_TELEPHONE_NUMBER.equals(fromForm))
{
return TELEPHONE;
}
if(CallRecord.FORM_RADIO.equals(toForm))
{
return PRIVATE;
}
return UNKNOWN;
}
/**
* SQL condition on the to_form and from_form columns that selects the calls of this type, using the same rules as
* {@link #from(String, String)}. The values are constants, so the condition has no parameters.
*/
public String getWhereClause()
{
String patch = "'" + CallRecord.FORM_PATCH_GROUP + "'";
String group = "'" + CallRecord.FORM_TALKGROUP + "'";
String radio = "'" + CallRecord.FORM_RADIO + "'";
String telephone = "'" + FORM_TELEPHONE_NUMBER + "'";
String fromNotTelephone = "(from_form IS NULL OR from_form <> " + telephone + ")";
return switch(this)
{
case PATCH -> "to_form = " + patch;
case GROUP -> "to_form = " + group;
case TELEPHONE -> "(to_form = " + telephone + " OR (from_form = " + telephone + " AND (to_form IS NULL " +
"OR to_form NOT IN (" + patch + ", " + group + "))))";
case PRIVATE -> "(to_form = " + radio + " AND " + fromNotTelephone + ")";
case UNKNOWN -> "((to_form IS NULL OR to_form NOT IN (" + patch + ", " + group + ", " + radio + ", " +
telephone + ")) AND " + fromNotTelephone + ")";
};
}
/**
* Label for selecting the type in a search filter (the unknown type is labeled Other)
*/
public String getFilterLabel()
{
return this == UNKNOWN ? "Other" : mLabel;
}
@Override
public String toString()
{
return mLabel;
}
}

View File

@@ -1,125 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Set;
/**
* Storage operations for call audio events in one database schema. Each method uses the connection from the caller
* so that the caller controls pooling and transactions.
*/
public interface ICallRepository
{
/**
* Inserts the call and assigns the generated row id to the call.
* @return generated row id
*/
long insert(Connection connection, CallRecord call) throws SQLException;
/**
* Inserts the calls in a single batch without retrieving the generated ids.
*/
void insertBatch(Connection connection, List<CallRecord> calls) throws SQLException;
/**
* Updates the existing call row identified by the call's id.
* @return true if the row exists and was updated
*/
boolean update(Connection connection, CallRecord call) throws SQLException;
/**
* Marks calls left in the active state by a previous session as interrupted.
* @return count of calls updated
*/
int markInterrupted(Connection connection) throws SQLException;
/**
* Deletes the calls that are in progress. Used when switching databases: calls in progress continue in the new
* database, so their rows are removed from the old database.
* @return count of calls deleted
*/
int deleteActive(Connection connection) throws SQLException;
/**
* Calls matching the criteria, newest first.
*/
List<CallRecord> search(Connection connection, CallSearchCriteria criteria, int offset, int limit)
throws SQLException;
/**
* Count of calls matching the criteria
*/
long count(Connection connection, CallSearchCriteria criteria) throws SQLException;
/**
* Total number of calls
*/
long count(Connection connection) throws SQLException;
/**
* Page of calls in id order with an id greater than the argument, for transfers between databases.
*/
List<CallRecord> readPage(Connection connection, long afterId, int limit) throws SQLException;
/**
* Transfer keys of all calls (see {@link CallRecord#getTransferKey()})
*/
Set<String> getTransferKeys(Connection connection) throws SQLException;
/**
* Calls with an available recording, oldest first.
* @param startedBefore only calls that started before this time, or 0 for any time
*/
List<CallRecord> getRecordedCalls(Connection connection, long startedBefore, int limit) throws SQLException;
/**
* Calls that are not in progress and started before the time, oldest first.
*/
List<CallRecord> getCallsStartedBefore(Connection connection, long startedBefore, int limit) throws SQLException;
/**
* Completed calls that started before the time and are duplicates, or Do Not Monitor calls without an alias record
* option, oldest first.
*/
List<CallRecord> getDuplicateAndDoNotMonitorCalls(Connection connection, long startedBefore, int limit)
throws SQLException;
/**
* Total size in bytes of all available recordings
*/
long getRecordedFileSize(Connection connection) throws SQLException;
/**
* Deletes the call rows
*/
void delete(Connection connection, List<Long> ids) throws SQLException;
/**
* Clears the recording file of the calls and marks their recordings deleted, keeping the call rows.
*/
void markRecordingsDeleted(Connection connection, List<Long> ids) throws SQLException;
/**
* Schema that holds the calls table
*/
String getSchema();
}

View File

@@ -1,285 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
import io.github.dsheirer.alias.Alias;
import io.github.dsheirer.alias.id.AliasID;
import io.github.dsheirer.alias.id.radio.P25FullyQualifiedRadio;
import io.github.dsheirer.alias.id.radio.Radio;
import io.github.dsheirer.alias.id.radio.RadioRange;
import io.github.dsheirer.alias.id.talkgroup.P25FullyQualifiedTalkgroup;
import io.github.dsheirer.alias.id.talkgroup.Talkgroup;
import io.github.dsheirer.alias.id.talkgroup.TalkgroupRange;
import io.github.dsheirer.protocol.Protocol;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
/**
* Search filter for the TO or FROM identifier of a call. The filter either matches typed text against the formatted
* identifier (or the exact identifier value when the text is a number), or matches the identifiers of a selected
* alias: calls of the alias's alias list whose identifier value is one of the alias's values or ranges, or whose fully
* qualified (roaming) address is one of the alias's fully qualified identifiers. This uses the same matching as the
* alias list, so a search for an alias finds the calls that the alias list currently aliases with that alias.
*
* @param text typed text, or empty for no text filter (ignored when an alias is selected)
* @param aliasName of the selected alias, or null
* @param aliasList name of the selected alias, or null
* @param ranges of identifier values for the selected alias
* @param fullyQualified addresses for the selected alias
*/
public record IdentifierFilter(String text, String aliasName, String aliasList, List<ValueRange> ranges,
List<FullyQualifiedAddress> fullyQualified)
{
/**
* Range of identifier values (inclusive) for a protocol
*/
public record ValueRange(Protocol protocol, int min, int max)
{
public boolean contains(Protocol callProtocol, long value)
{
return protocol == callProtocol && min <= value && value <= max;
}
}
/**
* Fully qualified identifier address (wacn.system.id) for a protocol
*/
public record FullyQualifiedAddress(Protocol protocol, String address) {}
public IdentifierFilter
{
text = text == null ? "" : text.trim();
ranges = ranges == null ? List.of() : List.copyOf(ranges);
fullyQualified = fullyQualified == null ? List.of() : List.copyOf(fullyQualified);
}
/**
* Filter that matches every call
*/
public static IdentifierFilter none()
{
return new IdentifierFilter("", null, null, null, null);
}
/**
* Filter for typed text
*/
public static IdentifierFilter text(String text)
{
return new IdentifierFilter(text, null, null, null, null);
}
/**
* Filter for the talkgroup identifiers (talkgroups, ranges, fully qualified talkgroups) of the alias
*/
public static IdentifierFilter talkgroupAlias(Alias alias)
{
List<ValueRange> ranges = new ArrayList<>();
List<FullyQualifiedAddress> fullyQualified = new ArrayList<>();
for(AliasID id: alias.getAliasIdentifiers())
{
if(!id.isValid())
{
continue;
}
if(id instanceof P25FullyQualifiedTalkgroup fqt)
{
fullyQualified.add(new FullyQualifiedAddress(fqt.getProtocol(), fqt.getHashKey()));
}
else if(id instanceof Talkgroup talkgroup)
{
ranges.add(new ValueRange(talkgroup.getProtocol(), talkgroup.getValue(), talkgroup.getValue()));
}
else if(id instanceof TalkgroupRange range)
{
ranges.add(new ValueRange(range.getProtocol(), range.getMinTalkgroup(), range.getMaxTalkgroup()));
}
}
return new IdentifierFilter("", alias.getName(), alias.getAliasListName(), ranges, fullyQualified);
}
/**
* Filter for the radio identifiers (radios, ranges, fully qualified radios) of the alias
*/
public static IdentifierFilter radioAlias(Alias alias)
{
List<ValueRange> ranges = new ArrayList<>();
List<FullyQualifiedAddress> fullyQualified = new ArrayList<>();
for(AliasID id: alias.getAliasIdentifiers())
{
if(!id.isValid())
{
continue;
}
if(id instanceof P25FullyQualifiedRadio fqr)
{
fullyQualified.add(new FullyQualifiedAddress(fqr.getProtocol(), fqr.getHashKey()));
}
else if(id instanceof Radio radio)
{
ranges.add(new ValueRange(radio.getProtocol(), radio.getValue(), radio.getValue()));
}
else if(id instanceof RadioRange range)
{
ranges.add(new ValueRange(range.getProtocol(), range.getMinRadio(), range.getMaxRadio()));
}
}
return new IdentifierFilter("", alias.getName(), alias.getAliasListName(), ranges, fullyQualified);
}
/**
* Indicates if the alias has talkgroup identifiers that a talkgroup alias filter can search for
*/
public static boolean hasTalkgroups(Alias alias)
{
IdentifierFilter filter = talkgroupAlias(alias);
return !filter.ranges().isEmpty() || !filter.fullyQualified().isEmpty();
}
/**
* Indicates if the alias has radio identifiers that a radio alias filter can search for
*/
public static boolean hasRadios(Alias alias)
{
IdentifierFilter filter = radioAlias(alias);
return !filter.ranges().isEmpty() || !filter.fullyQualified().isEmpty();
}
/**
* Indicates if this filter is for a selected alias
*/
public boolean isAlias()
{
return aliasName != null;
}
/**
* Indicates if this filter doesn't filter anything. An alias filter always filters: an alias without matching
* identifiers matches no calls.
*/
public boolean isEmpty()
{
return !isAlias() && text.isEmpty();
}
/**
* Evaluates the filter against a call identifier in memory, using the same rules as the database query.
* @param call to evaluate
* @param formatted identifier text
* @param value of the identifier, or null
* @param fullyQualifiedAddress of the identifier, or null
* @param formMatches true if the identifier form is the form that the alias identifiers apply to
* @param patched talkgroups patched into the TO patch group, which also match, or an empty list
*/
boolean matches(CallRecord call, String formatted, Long value, String fullyQualifiedAddress, boolean formMatches,
List<PatchedTalkgroup> patched)
{
if(isAlias())
{
if(!formMatches || call.getAliasList() == null || aliasList == null ||
!call.getAliasList().equalsIgnoreCase(aliasList))
{
return false;
}
Protocol protocol = call.getProtocolValue();
for(PatchedTalkgroup talkgroup: patched)
{
if(matchesAlias(protocol, talkgroup.value(), talkgroup.fullyQualified()))
{
return true;
}
}
return matchesAlias(protocol, value, fullyQualifiedAddress);
}
if(text.isEmpty())
{
return true;
}
Long parsed = CallSearchCriteria.parseValue(text);
if(parsed != null)
{
if(parsed.equals(value))
{
return true;
}
for(PatchedTalkgroup talkgroup: patched)
{
if(talkgroup.value() == parsed)
{
return true;
}
}
}
return formatted != null && formatted.toLowerCase(Locale.ROOT).contains(text.toLowerCase(Locale.ROOT));
}
/**
* Indicates if the identifier value or fully qualified address matches the alias identifiers
*/
private boolean matchesAlias(Protocol protocol, Long value, String fullyQualifiedAddress)
{
if(fullyQualifiedAddress != null)
{
for(FullyQualifiedAddress address: fullyQualified)
{
if(address.protocol() == protocol && address.address().equals(fullyQualifiedAddress))
{
return true;
}
}
return false;
}
if(value != null)
{
for(ValueRange range: ranges)
{
if(range.contains(protocol, value))
{
return true;
}
}
}
return false;
}
@Override
public String toString()
{
return isAlias() ? aliasName + " (" + aliasList + ")" : text;
}
}

View File

@@ -1,34 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
/**
* A talkgroup that is patched into the patch group of a call. The protocol is the protocol of the call.
*
* @param value of the talkgroup
* @param fullyQualified address (wacn.system.id) of a fully qualified (roaming) talkgroup, or null
*/
public record PatchedTalkgroup(long value, String fullyQualified)
{
@Override
public String toString()
{
return fullyQualified != null ? value + "(" + fullyQualified + ")" : String.valueOf(value);
}
}

View File

@@ -1,79 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
/**
* State of the audio recording file for a call
*/
public enum RecordingState
{
/**
* Call is not recorded
*/
NONE("Not Recorded"),
/**
* Recording is being written
*/
RECORDING("Recording"),
/**
* Recording is complete and the file is available
*/
RECORDED("Recorded"),
/**
* Recording file was deleted by an age-off rule or by the user
*/
DELETED("Deleted"),
/**
* Recording failed with an error
*/
FAILED("Failed");
private final String mLabel;
RecordingState(String label)
{
mLabel = label;
}
@Override
public String toString()
{
return mLabel;
}
/**
* Parses the stored value, defaulting to NONE for unrecognized values.
*/
public static RecordingState fromValue(String value)
{
if(value != null)
{
try
{
return RecordingState.valueOf(value);
}
catch(IllegalArgumentException iae)
{
//Fall through
}
}
return NONE;
}
}

View File

@@ -1,75 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.dialect;
import io.github.dsheirer.database.DatabaseConfiguration;
import java.nio.file.Path;
/**
* Built-in H2 embedded database, stored in the application 'db' directory.
*/
public class H2Dialect implements IDatabaseDialect
{
public static final String DATABASE_FILE_NAME = "sdrtrunk";
@Override
public String getDriverClass()
{
return "org.h2.Driver";
}
@Override
public int getDefaultPort()
{
return 0;
}
@Override
public boolean isNetwork()
{
return false;
}
@Override
public boolean requiresDatabaseName()
{
return false;
}
@Override
public String getJdbcUrl(DatabaseConfiguration configuration, Path databaseDirectory)
{
//DB_CLOSE_ON_EXIT=FALSE: the application closes the pool during shutdown, after the last call update.
return "jdbc:h2:file:" + databaseDirectory.resolve(DATABASE_FILE_NAME).toAbsolutePath() +
";DB_CLOSE_ON_EXIT=FALSE";
}
@Override
public String getIdentityColumn()
{
return "BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY";
}
@Override
public String getDropSchemaStatement(String schema)
{
return "DROP SCHEMA IF EXISTS " + schema + " CASCADE";
}
}

View File

@@ -1,77 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.dialect;
import io.github.dsheirer.database.DatabaseConfiguration;
import java.nio.file.Path;
/**
* Per-engine connection settings and SQL differences for a call database. Everything else that sdrtrunk sends to
* the database is portable SQL shared by all engines.
*
* All supported engines support schemas, so sdrtrunk always qualifies its tables with the configured schema name.
*/
public interface IDatabaseDialect
{
/**
* JDBC driver class name
*/
String getDriverClass();
/**
* Default TCP port for a network database server, or 0 for an embedded database.
*/
int getDefaultPort();
/**
* Indicates if this is a network database server that needs a host, port and credentials.
*/
boolean isNetwork();
/**
* Indicates if the engine needs a database name in addition to the schema name.
*/
boolean requiresDatabaseName();
/**
* JDBC URL for the configuration
* @param configuration with the host, port and database name
* @param databaseDirectory for embedded database files
*/
String getJdbcUrl(DatabaseConfiguration configuration, Path databaseDirectory);
/**
* Column definition for an auto-generated 64-bit primary key.
*/
String getIdentityColumn();
/**
* Statement that creates the schema when it doesn't exist.
*/
default String getCreateSchemaStatement(String schema)
{
return "CREATE SCHEMA IF NOT EXISTS " + schema;
}
/**
* Statement that removes the schema and all of its tables.
*/
String getDropSchemaStatement(String schema);
}

View File

@@ -1,72 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.dialect;
import io.github.dsheirer.database.DatabaseConfiguration;
import java.nio.file.Path;
/**
* MariaDB network database server. In MariaDB a schema is a database.
*/
public class MariaDBDialect implements IDatabaseDialect
{
@Override
public String getDriverClass()
{
return "org.mariadb.jdbc.Driver";
}
@Override
public int getDefaultPort()
{
return 3306;
}
@Override
public boolean isNetwork()
{
return true;
}
@Override
public boolean requiresDatabaseName()
{
return false;
}
@Override
public String getJdbcUrl(DatabaseConfiguration configuration, Path databaseDirectory)
{
return "jdbc:mariadb://" + configuration.host() + ":" + configuration.port() + "/";
}
@Override
public String getIdentityColumn()
{
return "BIGINT AUTO_INCREMENT PRIMARY KEY";
}
@Override
public String getDropSchemaStatement(String schema)
{
//Dropping a MariaDB schema (database) drops all of its tables
return "DROP SCHEMA IF EXISTS " + schema;
}
}

View File

@@ -1,72 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.dialect;
import io.github.dsheirer.database.DatabaseConfiguration;
import java.nio.file.Path;
/**
* PostgreSQL network database server. The schema lives inside the database named in the configuration.
*/
public class PostgreSQLDialect implements IDatabaseDialect
{
@Override
public String getDriverClass()
{
return "org.postgresql.Driver";
}
@Override
public int getDefaultPort()
{
return 5432;
}
@Override
public boolean isNetwork()
{
return true;
}
@Override
public boolean requiresDatabaseName()
{
return true;
}
@Override
public String getJdbcUrl(DatabaseConfiguration configuration, Path databaseDirectory)
{
return "jdbc:postgresql://" + configuration.host() + ":" + configuration.port() + "/" +
configuration.database();
}
@Override
public String getIdentityColumn()
{
return "BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY";
}
@Override
public String getDropSchemaStatement(String schema)
{
return "DROP SCHEMA IF EXISTS " + schema + " CASCADE";
}
}

View File

@@ -21,9 +21,6 @@ package io.github.dsheirer.gui;
import io.github.dsheirer.alias.AliasModel; import io.github.dsheirer.alias.AliasModel;
import io.github.dsheirer.audio.playback.AudioPlaybackManager; import io.github.dsheirer.audio.playback.AudioPlaybackManager;
import io.github.dsheirer.call.CallManager;
import io.github.dsheirer.database.DatabaseManager;
import io.github.dsheirer.gui.calls.CallsView;
import io.github.dsheirer.eventbus.MyEventBus; import io.github.dsheirer.eventbus.MyEventBus;
import io.github.dsheirer.gui.audio.AudioView; import io.github.dsheirer.gui.audio.AudioView;
import io.github.dsheirer.gui.broadcast.BroadcastStatusView; import io.github.dsheirer.gui.broadcast.BroadcastStatusView;
@@ -131,7 +128,6 @@ public class MainWindow
private final MainSpectralDisplay mSpectralDisplay; private final MainSpectralDisplay mSpectralDisplay;
private final HBox mSpectralHiddenBar; private final HBox mSpectralHiddenBar;
private final NowPlayingView mNowPlayingView; private final NowPlayingView mNowPlayingView;
private final CallsView mCallsView;
private final TabPane mTabPane = new TabPane(); private final TabPane mTabPane = new TabPane();
private BroadcastStatusView mBroadcastStatusView; private BroadcastStatusView mBroadcastStatusView;
private StatusBox mStatusBox; private StatusBox mStatusBox;
@@ -159,14 +155,11 @@ public class MainWindow
* @param mapService for the map * @param mapService for the map
* @param resourceMonitor for the status bar * @param resourceMonitor for the status bar
* @param diagnosticMonitor for the reports * @param diagnosticMonitor for the reports
* @param databaseManager for the Calls tab
* @param callManager for live call updates in the Calls tab
* @param exitHandler that shuts down the application, invoked on a background thread * @param exitHandler that shuts down the application, invoked on a background thread
*/ */
public MainWindow(UserPreferences userPreferences, PlaylistManager playlistManager, TunerManager tunerManager, public MainWindow(UserPreferences userPreferences, PlaylistManager playlistManager, TunerManager tunerManager,
AudioPlaybackManager audioPlaybackManager, AliasModel aliasModel, IconModel iconModel, AudioPlaybackManager audioPlaybackManager, AliasModel aliasModel, IconModel iconModel,
MapService mapService, ResourceMonitor resourceMonitor, DiagnosticMonitor diagnosticMonitor, MapService mapService, ResourceMonitor resourceMonitor, DiagnosticMonitor diagnosticMonitor,
DatabaseManager databaseManager, CallManager callManager,
Runnable exitHandler) Runnable exitHandler)
{ {
mUserPreferences = userPreferences; mUserPreferences = userPreferences;
@@ -189,7 +182,6 @@ public class MainWindow
boolean detailsVisible = mPreferences.getBoolean(PREFERENCE_NOW_PLAYING_DETAILS_VISIBLE, true); boolean detailsVisible = mPreferences.getBoolean(PREFERENCE_NOW_PLAYING_DETAILS_VISIBLE, true);
mNowPlayingView = new NowPlayingView(playlistManager, iconModel, userPreferences, detailsVisible); mNowPlayingView = new NowPlayingView(playlistManager, iconModel, userPreferences, detailsVisible);
mCallsView = new CallsView(databaseManager, callManager, audioPlaybackManager, aliasModel);
createTabs(mapService, iconModel); createTabs(mapService, iconModel);
URL stylesheet = MainWindow.class.getResource("/main_window.css"); URL stylesheet = MainWindow.class.getResource("/main_window.css");
@@ -306,7 +298,6 @@ public class MainWindow
public void dispose() public void dispose()
{ {
mAudioView.dispose(); mAudioView.dispose();
mCallsView.dispose();
if(mBroadcastStatusView != null) if(mBroadcastStatusView != null)
{ {
@@ -361,7 +352,6 @@ public class MainWindow
new RadioReferencePlaylistActions(mPlaylistManager), true); new RadioReferencePlaylistActions(mPlaylistManager), true);
Tab nowPlaying = new Tab("Now Playing", mNowPlayingView); Tab nowPlaying = new Tab("Now Playing", mNowPlayingView);
Tab calls = new Tab("Calls", mCallsView);
Tab map = new Tab("Map", mapView); Tab map = new Tab("Map", mapView);
Tab tuners = new Tab("Tuners", new io.github.dsheirer.source.tuner.ui.TunerView(mTunerManager, Tab tuners = new Tab("Tuners", new io.github.dsheirer.source.tuner.ui.TunerView(mTunerManager,
mUserPreferences)); mUserPreferences));
@@ -374,7 +364,7 @@ public class MainWindow
playlist.setGraphic(playIcon); playlist.setGraphic(playIcon);
playlist.setContent(new Region()); playlist.setContent(new Region());
mTabPane.getTabs().addAll(nowPlaying, calls, map, tuners, playlist); mTabPane.getTabs().addAll(nowPlaying, map, tuners, playlist);
mTabPane.setTabClosingPolicy(TabPane.TabClosingPolicy.UNAVAILABLE); mTabPane.setTabClosingPolicy(TabPane.TabClosingPolicy.UNAVAILABLE);
mTabPane.getStyleClass().add("main-tab-pane"); mTabPane.getStyleClass().add("main-tab-pane");
mTabPane.getSelectionModel().selectedItemProperty().addListener((observable, oldTab, newTab) -> { mTabPane.getSelectionModel().selectedItemProperty().addListener((observable, oldTab, newTab) -> {

View File

@@ -38,12 +38,11 @@ import io.github.dsheirer.log.ApplicationLog;
import io.github.dsheirer.map.MapService; import io.github.dsheirer.map.MapService;
import io.github.dsheirer.module.log.EventLogManager; import io.github.dsheirer.module.log.EventLogManager;
import io.github.dsheirer.monitor.DiagnosticMonitor; import io.github.dsheirer.monitor.DiagnosticMonitor;
import io.github.dsheirer.call.CallManager;
import io.github.dsheirer.database.DatabaseManager;
import io.github.dsheirer.monitor.ResourceMonitor; import io.github.dsheirer.monitor.ResourceMonitor;
import io.github.dsheirer.playlist.PlaylistManager; import io.github.dsheirer.playlist.PlaylistManager;
import io.github.dsheirer.preference.UserPreferences; import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.properties.SystemProperties; import io.github.dsheirer.properties.SystemProperties;
import io.github.dsheirer.record.AudioRecordingManager;
import io.github.dsheirer.sample.Listener; import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.settings.MapViewSetting; import io.github.dsheirer.settings.MapViewSetting;
import io.github.dsheirer.settings.SettingsManager; import io.github.dsheirer.settings.SettingsManager;
@@ -73,8 +72,7 @@ public class SDRTrunk implements Listener<TunerEvent>
{ {
private final static Logger mLog = LoggerFactory.getLogger(SDRTrunk.class); private final static Logger mLog = LoggerFactory.getLogger(SDRTrunk.class);
private CallManager mCallManager; private AudioRecordingManager mAudioRecordingManager;
private DatabaseManager mDatabaseManager;
private AudioStreamingManager mAudioStreamingManager; private AudioStreamingManager mAudioStreamingManager;
private DiagnosticMonitor mDiagnosticMonitor; private DiagnosticMonitor mDiagnosticMonitor;
private IconModel mIconModel = new IconModel(); private IconModel mIconModel = new IconModel();
@@ -160,12 +158,9 @@ public class SDRTrunk implements Listener<TunerEvent>
mTunerManager, headless); mTunerManager, headless);
mDiagnosticMonitor.start(); mDiagnosticMonitor.start();
mDatabaseManager = new DatabaseManager(mUserPreferences);
mDatabaseManager.start();
if(!headless) if(!headless)
{ {
mWindowManager = new WindowManager(mUserPreferences, mTunerManager, mPlaylistManager, mDatabaseManager); mWindowManager = new WindowManager(mUserPreferences, mTunerManager, mPlaylistManager);
} }
CalibrationManager calibrationManager = CalibrationManager.getInstance(mUserPreferences); CalibrationManager calibrationManager = CalibrationManager.getInstance(mUserPreferences);
@@ -176,9 +171,8 @@ public class SDRTrunk implements Listener<TunerEvent>
AudioPlaybackManager audioPlaybackManager = new AudioPlaybackManager(mUserPreferences); AudioPlaybackManager audioPlaybackManager = new AudioPlaybackManager(mUserPreferences);
mCallManager = new CallManager(mUserPreferences, mDatabaseManager); mAudioRecordingManager = new AudioRecordingManager(mUserPreferences);
mCallManager.start(); mAudioRecordingManager.start();
mResourceMonitor.setDatabasePreference(mUserPreferences.getDatabasePreference());
mAudioStreamingManager = new AudioStreamingManager(mPlaylistManager.getBroadcastModel(), BroadcastFormat.MP3, mAudioStreamingManager = new AudioStreamingManager(mPlaylistManager.getBroadcastModel(), BroadcastFormat.MP3,
mUserPreferences); mUserPreferences);
@@ -188,7 +182,7 @@ public class SDRTrunk implements Listener<TunerEvent>
mPlaylistManager.getChannelProcessingManager().addAudioSegmentListener(duplicateCallDetector); mPlaylistManager.getChannelProcessingManager().addAudioSegmentListener(duplicateCallDetector);
mPlaylistManager.getChannelProcessingManager().addAudioSegmentListener(audioPlaybackManager); mPlaylistManager.getChannelProcessingManager().addAudioSegmentListener(audioPlaybackManager);
mPlaylistManager.getChannelProcessingManager().addAudioSegmentListener(mCallManager); mPlaylistManager.getChannelProcessingManager().addAudioSegmentListener(mAudioRecordingManager);
mPlaylistManager.getChannelProcessingManager().addAudioSegmentListener(mAudioStreamingManager); mPlaylistManager.getChannelProcessingManager().addAudioSegmentListener(mAudioStreamingManager);
MapService mapService = new MapService(aliasModel, mIconModel); MapService mapService = new MapService(aliasModel, mIconModel);
@@ -199,7 +193,7 @@ public class SDRTrunk implements Listener<TunerEvent>
mResourceMonitor.start(); mResourceMonitor.start();
mMainWindow = FxToolkit.callAndWait(() -> new MainWindow(mUserPreferences, mPlaylistManager, mMainWindow = FxToolkit.callAndWait(() -> new MainWindow(mUserPreferences, mPlaylistManager,
mTunerManager, audioPlaybackManager, aliasModel, mIconModel, mapService, mResourceMonitor, mTunerManager, audioPlaybackManager, aliasModel, mIconModel, mapService, mResourceMonitor,
mDiagnosticMonitor, mDatabaseManager, mCallManager, this::processShutdown)); mDiagnosticMonitor, this::processShutdown));
} }
TunerSpectralDisplayManager tunerSpectralDisplayManager = new TunerSpectralDisplayManager( TunerSpectralDisplayManager tunerSpectralDisplayManager = new TunerSpectralDisplayManager(
@@ -332,9 +326,7 @@ public class SDRTrunk implements Listener<TunerEvent>
mLog.info("Stopping channels ..."); mLog.info("Stopping channels ...");
mPlaylistManager.getChannelProcessingManager().shutdown(); mPlaylistManager.getChannelProcessingManager().shutdown();
mCallManager.stop(); mAudioRecordingManager.stop();
mLog.info("Closing call database ...");
mDatabaseManager.stop();
mResourceMonitor.stop(); mResourceMonitor.stop();
mLog.info("Stopping tuners ..."); mLog.info("Stopping tuners ...");

View File

@@ -25,7 +25,6 @@ import io.github.dsheirer.gui.icon.IconManager;
import io.github.dsheirer.gui.icon.ViewIconManagerRequest; import io.github.dsheirer.gui.icon.ViewIconManagerRequest;
import io.github.dsheirer.gui.playlist.PlaylistEditor; import io.github.dsheirer.gui.playlist.PlaylistEditor;
import io.github.dsheirer.gui.playlist.PlaylistEditorRequest; import io.github.dsheirer.gui.playlist.PlaylistEditorRequest;
import io.github.dsheirer.database.DatabaseManager;
import io.github.dsheirer.gui.playlist.channelMap.ChannelMapEditor; import io.github.dsheirer.gui.playlist.channelMap.ChannelMapEditor;
import io.github.dsheirer.gui.playlist.channelMap.ViewChannelMapEditorRequest; import io.github.dsheirer.gui.playlist.channelMap.ViewChannelMapEditorRequest;
import io.github.dsheirer.gui.preference.UserPreferencesEditor; import io.github.dsheirer.gui.preference.UserPreferencesEditor;
@@ -71,7 +70,6 @@ public class WindowManager
private PlaylistManager mPlaylistManager; private PlaylistManager mPlaylistManager;
private TunerManager mTunerManager; private TunerManager mTunerManager;
private UserPreferences mUserPreferences; private UserPreferences mUserPreferences;
private final DatabaseManager mDatabaseManager;
private UserPreferencesEditor mUserPreferencesEditor; private UserPreferencesEditor mUserPreferencesEditor;
private MessageRecordingViewer mMessageRecordingViewer; private MessageRecordingViewer mMessageRecordingViewer;
@@ -87,13 +85,10 @@ public class WindowManager
* @param userPreferences for the windows and their stored locations * @param userPreferences for the windows and their stored locations
* @param tunerManager for the playlist editor * @param tunerManager for the playlist editor
* @param playlistManager for the playlist and channel map editors * @param playlistManager for the playlist and channel map editors
* @param databaseManager for the call database preference editor
*/ */
public WindowManager(UserPreferences userPreferences, TunerManager tunerManager, PlaylistManager playlistManager, public WindowManager(UserPreferences userPreferences, TunerManager tunerManager, PlaylistManager playlistManager)
DatabaseManager databaseManager)
{ {
mUserPreferences = userPreferences; mUserPreferences = userPreferences;
mDatabaseManager = databaseManager;
mTunerManager = tunerManager; mTunerManager = tunerManager;
mPlaylistManager = playlistManager; mPlaylistManager = playlistManager;
@@ -314,7 +309,7 @@ public class WindowManager
{ {
if(mUserPreferencesEditor == null) if(mUserPreferencesEditor == null)
{ {
mUserPreferencesEditor = new UserPreferencesEditor(mUserPreferences, mDatabaseManager); mUserPreferencesEditor = new UserPreferencesEditor(mUserPreferences);
} }
return mUserPreferencesEditor; return mUserPreferencesEditor;

View File

@@ -25,9 +25,6 @@ import io.github.dsheirer.alias.AliasList;
import io.github.dsheirer.alias.AliasModel; import io.github.dsheirer.alias.AliasModel;
import io.github.dsheirer.audio.AudioEvent; import io.github.dsheirer.audio.AudioEvent;
import io.github.dsheirer.audio.playback.AudioChannel; import io.github.dsheirer.audio.playback.AudioChannel;
import io.github.dsheirer.audio.playback.AudioPlaybackManager;
import io.github.dsheirer.audio.playback.ReplaySource;
import io.github.dsheirer.audio.playback.TalkgroupHold;
import io.github.dsheirer.icon.Icon; import io.github.dsheirer.icon.Icon;
import io.github.dsheirer.icon.IconModel; import io.github.dsheirer.icon.IconModel;
import io.github.dsheirer.identifier.Form; import io.github.dsheirer.identifier.Form;
@@ -83,10 +80,6 @@ public class AudioChannelView extends HBox
private final Label mStatusLabel = new Label(); private final Label mStatusLabel = new Label();
private final Label mElapsedLabel = new Label(); private final Label mElapsedLabel = new Label();
private final ToggleButton mMuteButton = new ToggleButton(); private final ToggleButton mMuteButton = new ToggleButton();
private final ToggleButton mHoldButton = new ToggleButton();
private final Label mHoldLabel = new Label();
private final AudioPlaybackManager mAudioPlaybackManager;
private final int mChannelIndex;
private final IconNode mMuteIcon = new IconNode(FontAwesome.VOLUME_UP); private final IconNode mMuteIcon = new IconNode(FontAwesome.VOLUME_UP);
private final Label mToLabel = new Label(NO_CALL); private final Label mToLabel = new Label(NO_CALL);
private final Label mToDetailLabel = new Label(); private final Label mToDetailLabel = new Label();
@@ -110,16 +103,12 @@ public class AudioChannelView extends HBox
* @param talkgroupFormatPreference for identifier formatting * @param talkgroupFormatPreference for identifier formatting
* @param updatesPerSecond rate that {@link #tick()} is invoked * @param updatesPerSecond rate that {@link #tick()} is invoked
* @param muteChangeListener notified on the FX thread when this channel's mute state changes * @param muteChangeListener notified on the FX thread when this channel's mute state changes
* @param audioPlaybackManager for setting the hold talkgroup, or null to hide the hold button
* @param channelIndex of this channel in the audio output
*/ */
public AudioChannelView(AudioChannel audioChannel, AliasModel aliasModel, IconModel iconModel, public AudioChannelView(AudioChannel audioChannel, AliasModel aliasModel, IconModel iconModel,
TalkgroupFormatPreference talkgroupFormatPreference, double updatesPerSecond, TalkgroupFormatPreference talkgroupFormatPreference, double updatesPerSecond,
Runnable muteChangeListener, AudioPlaybackManager audioPlaybackManager, int channelIndex) Runnable muteChangeListener)
{ {
mAudioChannel = audioChannel; mAudioChannel = audioChannel;
mAudioPlaybackManager = audioPlaybackManager;
mChannelIndex = channelIndex;
mAliasModel = aliasModel; mAliasModel = aliasModel;
mIconModel = iconModel; mIconModel = iconModel;
mTalkgroupFormatPreference = talkgroupFormatPreference; mTalkgroupFormatPreference = talkgroupFormatPreference;
@@ -154,8 +143,6 @@ public class AudioChannelView extends HBox
mChannelTag.setText(audioChannel.getChannelName()); mChannelTag.setText(audioChannel.getChannelName());
mChannelTag.getStyleClass().add("audio-channel-tag"); mChannelTag.getStyleClass().add("audio-channel-tag");
mChannelTag.getStyleClass().add("RIGHT".equals(audioChannel.getChannelName()) ? "audio-channel-tag-right" :
"audio-channel-tag-left");
mStatusLabel.getStyleClass().add("audio-status"); mStatusLabel.getStyleClass().add("audio-status");
mElapsedLabel.getStyleClass().add("audio-elapsed"); mElapsedLabel.getStyleClass().add("audio-elapsed");
mMuteIcon.setIconSize(15); mMuteIcon.setIconSize(15);
@@ -167,24 +154,9 @@ public class AudioChannelView extends HBox
mAudioChannel.setMuted(mMuteButton.isSelected()); mAudioChannel.setMuted(mMuteButton.isSelected());
updateMuted(); updateMuted();
}); });
IconNode holdIcon = new IconNode(FontAwesome.THUMB_TACK);
holdIcon.setIconSize(15);
holdIcon.getStyleClass().add("audio-button-icon");
mHoldButton.setGraphic(holdIcon);
mHoldButton.getStyleClass().addAll("audio-icon-button", "audio-hold-button");
mHoldButton.setFocusTraversable(true);
mHoldButton.setOnAction(event -> toggleHold());
mHoldButton.setVisible(audioPlaybackManager != null);
mHoldButton.setManaged(audioPlaybackManager != null);
mHoldLabel.getStyleClass().add("audio-hold-label");
mHoldLabel.setTextOverrun(OverrunStyle.ELLIPSIS);
mHoldLabel.setMinWidth(0);
mHoldLabel.setVisible(false);
mHoldLabel.setManaged(false);
Region headerSpacer = new Region(); Region headerSpacer = new Region();
HBox.setHgrow(headerSpacer, Priority.ALWAYS); HBox.setHgrow(headerSpacer, Priority.ALWAYS);
HBox header = new HBox(8, mChannelTag, mStatusLabel, mHoldLabel, headerSpacer, mElapsedLabel, mHoldButton, HBox header = new HBox(8, mChannelTag, mStatusLabel, headerSpacer, mElapsedLabel, mMuteButton);
mMuteButton);
header.setAlignment(Pos.CENTER_LEFT); header.setAlignment(Pos.CENTER_LEFT);
mToLabel.getStyleClass().add("audio-to"); mToLabel.getStyleClass().add("audio-to");
@@ -230,79 +202,6 @@ public class AudioChannelView extends HBox
mAudioChannel.addAudioEventListener(mAudioEventListener); mAudioChannel.addAudioEventListener(mAudioEventListener);
mAudioChannel.setIdentifierCollectionListener(mMetadataListener); mAudioChannel.setIdentifierCollectionListener(mMetadataListener);
mAudioChannel.setHoldListener(hold -> Platform.runLater(this::updateHold));
updateHold();
}
/**
* Holds the talkgroup of the current (or last) call on this channel, or releases the hold.
*/
private void toggleHold()
{
if(mAudioPlaybackManager == null)
{
return;
}
if(mAudioChannel.getHold() != null)
{
mAudioPlaybackManager.setHold(mChannelIndex, null);
}
else
{
TalkgroupHold hold = getCallHold();
if(hold != null)
{
mAudioPlaybackManager.setHold(mChannelIndex, hold);
}
}
updateHold();
}
/**
* Hold for the TO talkgroup of the current or last call, labeled with the talkgroup and its alias, or null.
*/
private TalkgroupHold getCallHold()
{
IdentifierCollection collection = mIdentifierCollection;
TalkgroupHold hold = TalkgroupHold.from(collection, null);
if(hold == null)
{
return null;
}
Identifier to = collection.getToIdentifier();
AliasList aliasList = mAliasModel != null ? mAliasModel.getAliasList(collection) : null;
List<Alias> aliases = getAliases(aliasList, to);
String label = format(to);
if(!aliases.isEmpty())
{
label = label + " " + Joiner.on(", ").skipNulls().join(aliases);
}
return new TalkgroupHold(hold.protocol(), hold.talkgroup(), label);
}
/**
* Updates the hold button and label from the channel's hold talkgroup. FX thread.
*/
private void updateHold()
{
TalkgroupHold hold = mAudioChannel.getHold();
boolean held = hold != null;
mHoldButton.setSelected(held);
mHoldButton.setDisable(!held && getCallHold() == null);
mHoldButton.setTooltip(new Tooltip(held ? "Release hold on talkgroup " + hold :
"Hold this talkgroup: only play calls to this talkgroup on the " + getChannelDescription()));
mHoldButton.setAccessibleText(held ? "Release hold" : "Hold talkgroup");
mHoldLabel.setText(held ? "HOLD " + hold : "");
mHoldLabel.setVisible(held);
mHoldLabel.setManaged(held);
pseudoClassStateChanged(AudioView.HELD, held);
} }
/** /**
@@ -312,7 +211,6 @@ public class AudioChannelView extends HBox
{ {
mAudioChannel.removeAudioEventListener(mAudioEventListener); mAudioChannel.removeAudioEventListener(mAudioEventListener);
mAudioChannel.removeAudioMetadataListener(); mAudioChannel.removeAudioMetadataListener();
mAudioChannel.setHoldListener(null);
} }
/** /**
@@ -387,7 +285,6 @@ public class AudioChannelView extends HBox
switch(audioEvent.getType()) switch(audioEvent.getType())
{ {
case AUDIO_STOPPED -> Platform.runLater(() -> setIdentifierCollection(null)); case AUDIO_STOPPED -> Platform.runLater(() -> setIdentifierCollection(null));
case REPLAY_STARTED, REPLAY_STOPPED -> Platform.runLater(this::updateReplay);
case AUDIO_MUTED, AUDIO_UNMUTED -> Platform.runLater(() -> { case AUDIO_MUTED, AUDIO_UNMUTED -> Platform.runLater(() -> {
updateMuted(); updateMuted();
mMuteChangeListener.run(); mMuteChangeListener.run();
@@ -439,35 +336,6 @@ public class AudioChannelView extends HBox
pseudoClassStateChanged(AudioView.ACTIVE, true); pseudoClassStateChanged(AudioView.ACTIVE, true);
updateDisplay(); updateDisplay();
updateElapsed(); updateElapsed();
updateHold();
}
/**
* Shows the recorded call that is replaying on this channel, or restores the call display when the replay ends.
* FX thread.
*/
private void updateReplay()
{
ReplaySource replay = mAudioChannel.getReplay();
if(replay != null && !replay.isFinished())
{
mActive = false;
mHasPlayed = true;
mCallStartNanos = System.nanoTime();
mToLabel.setText("Replay");
mToDetailLabel.setText("");
mFromBox.setVisible(false);
mContextLabel.setText(replay.getDescription());
setAlias(null);
pseudoClassStateChanged(AudioView.ACTIVE, true);
mStatusLabel.setText(mAudioChannel.isMuted() ? "MUTED" : "REPLAY");
}
else
{
pseudoClassStateChanged(AudioView.ACTIVE, false);
updateDisplay();
}
} }
/** /**
@@ -475,15 +343,6 @@ public class AudioChannelView extends HBox
*/ */
private void updateStatus() private void updateStatus()
{ {
ReplaySource replay = mAudioChannel.getReplay();
if(replay != null && !replay.isFinished())
{
mStatusLabel.setText(mAudioChannel.isMuted() ? "MUTED" : "REPLAY");
mElapsedLabel.setVisible(false);
return;
}
String status; String status;
if(mActive) if(mActive)

View File

@@ -73,7 +73,6 @@ public class AudioView extends HBox
private static final Logger mLog = LoggerFactory.getLogger(AudioView.class); private static final Logger mLog = LoggerFactory.getLogger(AudioView.class);
static final PseudoClass ACTIVE = PseudoClass.getPseudoClass("active"); static final PseudoClass ACTIVE = PseudoClass.getPseudoClass("active");
static final PseudoClass MUTED = PseudoClass.getPseudoClass("muted"); static final PseudoClass MUTED = PseudoClass.getPseudoClass("muted");
static final PseudoClass HELD = PseudoClass.getPseudoClass("held");
private static final double UPDATES_PER_SECOND = 25.0; private static final double UPDATES_PER_SECOND = 25.0;
private final AudioPlaybackManager mAudioPlaybackManager; private final AudioPlaybackManager mAudioPlaybackManager;
@@ -261,12 +260,10 @@ public class AudioView extends HBox
List<AudioChannel> channels = mAudioPlaybackManager.getAudioChannels(); List<AudioChannel> channels = mAudioPlaybackManager.getAudioChannels();
for(int x = 0; x < channels.size(); x++) for(AudioChannel channel: channels)
{ {
AudioChannel channel = channels.get(x);
AudioChannelView view = new AudioChannelView(channel, mAliasModel, mIconModel, AudioChannelView view = new AudioChannelView(channel, mAliasModel, mIconModel,
mUserPreferences.getTalkgroupFormatPreference(), UPDATES_PER_SECOND, this::updateMuted, mUserPreferences.getTalkgroupFormatPreference(), UPDATES_PER_SECOND, this::updateMuted);
mAudioPlaybackManager, x);
mChannelViews.add(view); mChannelViews.add(view);
mChannelsBox.getChildren().add(view); mChannelsBox.getChildren().add(view);
} }

View File

@@ -1,240 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.gui.calls;
import io.github.dsheirer.alias.Alias;
import io.github.dsheirer.alias.AliasModel;
import io.github.dsheirer.database.call.IdentifierFilter;
import javafx.css.PseudoClass;
import javafx.geometry.Side;
import javafx.scene.control.ContextMenu;
import javafx.scene.control.CustomMenuItem;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.control.Tooltip;
import javafx.scene.input.KeyCode;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
/**
* Search field for the TO (talkgroup) or FROM (radio) identifier of a call. As the user types, a list of matching
* aliases from the current alias lists drops down. Selecting an alias filters the calls by the alias's talkgroup or
* radio identifiers. Typing without selecting an alias filters by the identifier text or value.
*/
public class AliasSearchField extends TextField
{
private static final PseudoClass ALIAS_SELECTED = PseudoClass.getPseudoClass("alias-selected");
private static final int MAX_SUGGESTIONS = 25;
/**
* Identifier kind that the field searches
*/
public enum Kind
{
TALKGROUP,
RADIO
}
private final Kind mKind;
private final AliasModel mAliasModel;
private final ContextMenu mSuggestions = new ContextMenu();
private final Runnable mSearchAction;
private IdentifierFilter mAliasFilter;
private boolean mSettingText;
/**
* Constructs an instance
* @param kind of identifier to search
* @param aliasModel for the alias suggestions, or null for text search only
* @param prompt text
* @param searchAction invoked when the user selects an alias or presses enter
*/
public AliasSearchField(Kind kind, AliasModel aliasModel, String prompt, Runnable searchAction)
{
mKind = kind;
mAliasModel = aliasModel;
mSearchAction = searchAction;
setPromptText(prompt);
getStyleClass().add("calls-alias-search");
mSuggestions.setAutoHide(true);
updateTooltip();
textProperty().addListener((observable, oldValue, newValue) -> {
if(!mSettingText)
{
mAliasFilter = null;
pseudoClassStateChanged(ALIAS_SELECTED, false);
updateTooltip();
showSuggestions(newValue);
}
});
focusedProperty().addListener((observable, wasFocused, focused) -> {
if(!focused)
{
mSuggestions.hide();
}
});
setOnKeyPressed(event -> {
if(event.getCode() == KeyCode.ESCAPE)
{
mSuggestions.hide();
}
else if(event.getCode() == KeyCode.DOWN && !mSuggestions.getItems().isEmpty())
{
if(!mSuggestions.isShowing())
{
mSuggestions.show(this, Side.BOTTOM, 0, 0);
}
mSuggestions.getSkin().getNode().lookupAll(".menu-item").stream().findFirst()
.ifPresent(node -> node.requestFocus());
event.consume();
}
});
setOnAction(event -> {
mSuggestions.hide();
mSearchAction.run();
});
}
/**
* Current search filter: the selected alias, or the typed text.
*/
public IdentifierFilter getFilter()
{
return mAliasFilter != null ? mAliasFilter : IdentifierFilter.text(getText());
}
/**
* Clears the text and any selected alias
*/
public void reset()
{
mSettingText = true;
setText("");
mSettingText = false;
mAliasFilter = null;
pseudoClassStateChanged(ALIAS_SELECTED, false);
updateTooltip();
mSuggestions.hide();
}
/**
* Selects the alias as the search filter
*/
public void select(Alias alias)
{
mAliasFilter = mKind == Kind.TALKGROUP ? IdentifierFilter.talkgroupAlias(alias) :
IdentifierFilter.radioAlias(alias);
mSettingText = true;
setText(alias.getName());
positionCaret(getText().length());
mSettingText = false;
pseudoClassStateChanged(ALIAS_SELECTED, true);
updateTooltip();
mSuggestions.hide();
mSearchAction.run();
}
private void updateTooltip()
{
String what = mKind == Kind.TALKGROUP ? "talkgroup" : "radio";
if(mAliasFilter != null)
{
setTooltip(new Tooltip("Alias [" + mAliasFilter.aliasName() + "] in alias list [" +
mAliasFilter.aliasList() + "]: calls with the alias " + what + " identifiers"));
}
else
{
setTooltip(new Tooltip("Type a " + what + " alias name and select it from the list, or type part of the " +
what + " identifier or its exact value"));
}
}
/**
* Aliases (with identifiers of this field's kind) whose name contains the text, sorted by name.
*/
List<Alias> getMatchingAliases(String text)
{
List<Alias> matches = new ArrayList<>();
if(mAliasModel == null || text == null || text.isBlank())
{
return matches;
}
String lower = text.trim().toLowerCase(Locale.ROOT);
for(Alias alias: new ArrayList<>(mAliasModel.aliasList()))
{
if(alias.getName() != null && alias.getName().toLowerCase(Locale.ROOT).contains(lower) &&
(mKind == Kind.TALKGROUP ? IdentifierFilter.hasTalkgroups(alias) : IdentifierFilter.hasRadios(alias)))
{
matches.add(alias);
}
}
//Names that start with the text first, then alphabetical
matches.sort(Comparator.comparing((Alias alias) -> !alias.getName().toLowerCase(Locale.ROOT)
.startsWith(lower)).thenComparing(alias -> alias.getName().toLowerCase(Locale.ROOT))
.thenComparing(alias -> alias.getAliasListName() != null ? alias.getAliasListName() : ""));
return matches;
}
private void showSuggestions(String text)
{
List<Alias> matches = getMatchingAliases(text);
mSuggestions.getItems().clear();
if(matches.isEmpty() || !isFocused())
{
mSuggestions.hide();
return;
}
for(Alias alias: matches.subList(0, Math.min(MAX_SUGGESTIONS, matches.size())))
{
Label label = new Label(alias.getName() + " (" + (alias.getAliasListName() != null ?
alias.getAliasListName() : "no list") + ")");
CustomMenuItem item = new CustomMenuItem(label, true);
item.setOnAction(event -> select(alias));
mSuggestions.getItems().add(item);
}
if(matches.size() > MAX_SUGGESTIONS)
{
CustomMenuItem more = new CustomMenuItem(new Label((matches.size() - MAX_SUGGESTIONS) +
" more - keep typing to narrow the list"), false);
more.setDisable(true);
mSuggestions.getItems().add(more);
}
if(!mSuggestions.isShowing())
{
mSuggestions.show(this, Side.BOTTOM, 0, 0);
}
}
}

View File

@@ -1,151 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.gui.calls;
import io.github.dsheirer.alias.Alias;
import io.github.dsheirer.alias.AliasList;
import io.github.dsheirer.alias.AliasModel;
import io.github.dsheirer.database.call.CallRecord;
import io.github.dsheirer.database.call.PatchedTalkgroup;
/**
* Looks up the current aliases for the TO and FROM identifiers of a stored call, using the call's alias list from the
* alias model. Calls are aliased with the latest alias values, so historical calls pick up alias changes.
*/
public class CallAliasResolver
{
private final AliasModel mAliasModel;
/**
* Constructs an instance
* @param aliasModel with the current aliases, or null to disable alias lookup
*/
public CallAliasResolver(AliasModel aliasModel)
{
mAliasModel = aliasModel;
}
private AliasList getAliasList(CallRecord call)
{
if(mAliasModel == null || call == null || call.getAliasList() == null || call.getAliasList().isEmpty())
{
return null;
}
return mAliasModel.getAliasList(call.getAliasList());
}
/**
* Current alias for the TO talkgroup, patch group or radio of the call, or null.
*/
public Alias getToAlias(CallRecord call)
{
AliasList aliasList = getAliasList(call);
if(aliasList == null || call.getToValue() == null || call.getToValue() > Integer.MAX_VALUE)
{
return null;
}
int value = call.getToValue().intValue();
if(call.isToTalkgroup())
{
return aliasList.getTalkgroupAlias(call.getProtocolValue(), value, call.getToFullyQualified());
}
if(CallRecord.FORM_RADIO.equals(call.getToForm()))
{
return aliasList.getRadioAlias(call.getProtocolValue(), value, call.getToFullyQualified());
}
return null;
}
/**
* Current alias for the FROM radio of the call, or null.
*/
public Alias getFromAlias(CallRecord call)
{
AliasList aliasList = getAliasList(call);
if(aliasList == null || !call.isFromRadio() || call.getFromValue() == null ||
call.getFromValue() > Integer.MAX_VALUE)
{
return null;
}
return aliasList.getRadioAlias(call.getProtocolValue(), call.getFromValue().intValue(),
call.getFromFullyQualified());
}
/**
* Talkgroups patched into the TO patch group, with their current alias names, e.g. "1001 Fire Dispatch, 1002",
* or null when the call isn't a patch group call.
*/
public String getPatchedTalkgroups(CallRecord call)
{
if(call == null || call.getPatchedTalkgroups().isEmpty())
{
return null;
}
AliasList aliasList = getAliasList(call);
StringBuilder sb = new StringBuilder();
for(PatchedTalkgroup talkgroup: call.getPatchedTalkgroups())
{
if(sb.length() > 0)
{
sb.append(", ");
}
sb.append(talkgroup.value());
Alias alias = aliasList != null && talkgroup.value() <= Integer.MAX_VALUE ?
aliasList.getTalkgroupAlias(call.getProtocolValue(), (int)talkgroup.value(),
talkgroup.fullyQualified()) : null;
if(alias != null)
{
sb.append(" ").append(alias.getName());
}
}
return sb.toString();
}
/**
* Name of the current TO alias, or null
*/
public String getToAliasName(CallRecord call)
{
Alias alias = getToAlias(call);
return alias != null ? alias.getName() : null;
}
/**
* Name of the current FROM alias, or null
*/
public String getFromAliasName(CallRecord call)
{
Alias alias = getFromAlias(call);
return alias != null ? alias.getName() : null;
}
}

View File

@@ -1,370 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.gui.calls;
import io.github.dsheirer.audio.playback.AudioChannel;
import io.github.dsheirer.audio.playback.AudioPlaybackManager;
import io.github.dsheirer.audio.playback.ReplaySource;
import io.github.dsheirer.database.call.CallRecord;
import io.github.dsheirer.record.RecordingReader;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Platform;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.geometry.Pos;
import javafx.scene.control.Button;
import javafx.scene.control.CheckBox;
import javafx.scene.control.Label;
import javafx.scene.control.Slider;
import javafx.scene.control.Tooltip;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.util.Duration;
import jiconfont.icons.font_awesome.FontAwesome;
import jiconfont.javafx.IconNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
/**
* Replays call recordings in the Calls tab through the sdrtrunk audio channels (the same audio output, channels,
* mute and level meters as live calls). The audio playback manager chooses the channel: an idle channel, otherwise
* the left (or mono) channel, which drops the live call that it is playing.
*/
public class CallPlayer extends HBox
{
private static final Logger LOGGER = LoggerFactory.getLogger(CallPlayer.class);
private final AudioPlaybackManager mAudioPlaybackManager;
private final Button mPlayButton = new Button();
private final IconNode mPlayIcon = new IconNode(FontAwesome.PLAY);
private final Button mStopButton = new Button();
private final Slider mPositionSlider = new Slider(0, 1, 0);
private final Label mTimeLabel = new Label("0:00 / 0:00");
private final Label mCallLabel = new Label("Double-click a recorded call to replay it");
private final CheckBox mAutoPlayCheckBox = new CheckBox("Auto-play next");
private final ObjectProperty<CallRecord> mCurrentCall = new SimpleObjectProperty<>();
private final Timeline mProgressTimeline;
private CallAliasResolver mAliasResolver = new CallAliasResolver(null);
private Consumer<CallRecord> mFinishedListener;
private ReplaySource mReplay;
private long mLoadSequence;
/**
* Constructs an instance
* @param audioPlaybackManager that replays the calls, or null to disable replay
*/
public CallPlayer(AudioPlaybackManager audioPlaybackManager)
{
super(8);
mAudioPlaybackManager = audioPlaybackManager;
setAlignment(Pos.CENTER_LEFT);
getStyleClass().add("calls-player");
mPlayIcon.setIconSize(14);
mPlayIcon.fillProperty().bind(mPlayButton.textFillProperty());
mPlayButton.setGraphic(mPlayIcon);
mPlayButton.setTooltip(new Tooltip("Pause / resume"));
mPlayButton.setOnAction(event -> togglePause());
IconNode stopIcon = new IconNode(FontAwesome.STOP);
stopIcon.setIconSize(14);
stopIcon.fillProperty().bind(mStopButton.textFillProperty());
mStopButton.setGraphic(stopIcon);
mStopButton.setTooltip(new Tooltip("Stop the replay"));
mStopButton.setOnAction(event -> stop());
mPositionSlider.setPrefWidth(260);
mPositionSlider.setMinWidth(100);
mPositionSlider.valueChangingProperty().addListener((obs, old, changing) -> {
if(!changing)
{
seek();
}
});
mPositionSlider.setOnMouseReleased(event -> seek());
mTimeLabel.setMinWidth(Label.USE_PREF_SIZE);
mCallLabel.setMinWidth(0);
mAutoPlayCheckBox.setTooltip(new Tooltip("When a replay finishes, replay the next newer recorded call"));
mAutoPlayCheckBox.setMinWidth(Label.USE_PREF_SIZE);
HBox.setHgrow(mCallLabel, Priority.ALWAYS);
mCallLabel.setMaxWidth(Double.MAX_VALUE);
getChildren().addAll(mPlayButton, mStopButton, mPositionSlider, mTimeLabel, mCallLabel, mAutoPlayCheckBox);
mProgressTimeline = new Timeline(new KeyFrame(Duration.millis(100), event -> updateProgress()));
mProgressTimeline.setCycleCount(Timeline.INDEFINITE);
updateControls();
}
/**
* Sets the resolver for the current TO and FROM aliases shown for the replayed call
*/
public void setAliasResolver(CallAliasResolver aliasResolver)
{
mAliasResolver = aliasResolver;
}
/**
* Registers a listener for when a replay plays to the end (used for auto-play of the next call)
*/
public void setFinishedListener(Consumer<CallRecord> listener)
{
mFinishedListener = listener;
}
/**
* Indicates if auto-play of the next call is enabled
*/
public boolean isAutoPlay()
{
return mAutoPlayCheckBox.isSelected();
}
/**
* Call that is loaded in the player, or null
*/
public ObjectProperty<CallRecord> currentCallProperty()
{
return mCurrentCall;
}
/**
* Replays the recording of the call. The recording is read on a background thread. FX thread.
* @return true if the replay is starting
*/
public boolean play(CallRecord call)
{
if(call == null || !call.isPlayable())
{
return false;
}
if(mAudioPlaybackManager == null || mAudioPlaybackManager.getAudioChannels().isEmpty())
{
mCallLabel.setText("No audio output is available for replay");
return false;
}
Path path = Path.of(call.getFilePath());
if(!Files.exists(path))
{
mCallLabel.setText("Recording file not found: " + path.getFileName());
return false;
}
stopReplay();
long sequence = ++mLoadSequence;
String description = describe(call);
mCurrentCall.set(call);
mCallLabel.setText("Loading " + description);
updateControls();
CompletableFuture.supplyAsync(() -> {
try
{
return RecordingReader.read(path);
}
catch(Exception e)
{
throw new IllegalStateException(e.getMessage(), e);
}
}).whenComplete((samples, error) -> Platform.runLater(() -> {
if(sequence != mLoadSequence)
{
return; //Another call was selected while this one was loading
}
if(error != null)
{
Throwable cause = error.getCause() != null ? error.getCause() : error;
LOGGER.warn("Unable to replay recording [" + path + "] - " + cause.getMessage());
mCallLabel.setText("Unable to replay " + path.getFileName() + ": " + cause.getMessage());
mCurrentCall.set(null);
updateControls();
return;
}
ReplaySource replay = new ReplaySource(samples, call.getId(), description);
int channelIndex = mAudioPlaybackManager.replay(replay);
if(channelIndex < 0)
{
mCallLabel.setText("No audio output is available for replay");
mCurrentCall.set(null);
updateControls();
return;
}
mReplay = replay;
mCallLabel.setText(getChannelLabel(channelIndex) + description);
mProgressTimeline.play();
updateControls();
}));
return true;
}
private String getChannelLabel(int channelIndex)
{
List<AudioChannel> channels = mAudioPlaybackManager.getAudioChannels();
if(channels.size() > 1 && channelIndex < channels.size())
{
return channels.get(channelIndex).getChannelName() + ": ";
}
return "";
}
private String describe(CallRecord call)
{
StringBuilder sb = new StringBuilder();
sb.append(CallsView.formatTime(call.getStartTime()));
if(call.getToId() != null)
{
sb.append(" TO:").append(call.getToId());
String toAlias = mAliasResolver.getToAliasName(call);
if(toAlias != null)
{
sb.append(" ").append(toAlias);
}
}
if(call.getFromId() != null)
{
sb.append(" FROM:").append(call.getFromId());
String fromAlias = mAliasResolver.getFromAliasName(call);
if(fromAlias != null)
{
sb.append(" ").append(fromAlias);
}
}
return sb.toString();
}
private void togglePause()
{
if(mReplay != null)
{
mReplay.setPaused(!mReplay.isPaused());
updateControls();
}
}
/**
* Stops the replay. FX thread.
*/
public void stop()
{
mLoadSequence++;
stopReplay();
mCurrentCall.set(null);
mCallLabel.setText("Double-click a recorded call to replay it");
mPositionSlider.setValue(0);
mTimeLabel.setText("0:00 / 0:00");
updateControls();
}
private void stopReplay()
{
mProgressTimeline.stop();
if(mReplay != null)
{
mReplay.stop();
mReplay = null;
}
}
private void seek()
{
if(mReplay != null)
{
mReplay.seek(mPositionSlider.getValue());
}
}
/**
* Updates the position display and detects the end of the replay. FX thread.
*/
private void updateProgress()
{
ReplaySource replay = mReplay;
if(replay == null)
{
mProgressTimeline.stop();
return;
}
if(!mPositionSlider.isValueChanging())
{
mPositionSlider.setValue(replay.getFraction());
}
mTimeLabel.setText(format(replay.getPositionMillis()) + " / " + format(replay.getDurationMillis()));
if(replay.isFinished())
{
CallRecord finished = mCurrentCall.get();
boolean completed = replay.isCompleted();
stop();
if(completed && mFinishedListener != null && finished != null)
{
mFinishedListener.accept(finished);
}
}
}
private static String format(long millis)
{
long seconds = Math.max(0, millis / 1000);
return seconds / 60 + ":" + String.format("%02d", seconds % 60);
}
private void updateControls()
{
boolean loaded = mReplay != null;
mPlayButton.setDisable(!loaded);
mStopButton.setDisable(!loaded && mCurrentCall.get() == null);
mPositionSlider.setDisable(!loaded);
mPlayIcon.setIconCode(loaded && !mReplay.isPaused() ? FontAwesome.PAUSE : FontAwesome.PLAY);
}
/**
* Stops the replay and releases resources.
*/
public void dispose()
{
stop();
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -52,7 +52,7 @@ public class PlaylistEditorApplication extends Application
mPlaylistManager = new PlaylistManager(mUserPreferences, mTunerManager, aliasModel, eventLogManager, new IconModel()); mPlaylistManager = new PlaylistManager(mUserPreferences, mTunerManager, aliasModel, eventLogManager, new IconModel());
mPlaylistManager.init(); mPlaylistManager.init();
mWindowManager = new WindowManager(mUserPreferences, mTunerManager, mPlaylistManager, null); mWindowManager = new WindowManager(mUserPreferences, mTunerManager, mPlaylistManager);
} }
@Override @Override

View File

@@ -19,8 +19,6 @@
package io.github.dsheirer.gui.preference; package io.github.dsheirer.gui.preference;
import io.github.dsheirer.database.DatabaseManager;
import io.github.dsheirer.gui.preference.database.DatabasePreferenceEditor;
import io.github.dsheirer.gui.preference.application.AppearancePreferenceEditor; import io.github.dsheirer.gui.preference.application.AppearancePreferenceEditor;
import io.github.dsheirer.gui.preference.application.ApplicationPreferenceEditor; import io.github.dsheirer.gui.preference.application.ApplicationPreferenceEditor;
import io.github.dsheirer.gui.preference.calibration.VectorCalibrationPreferenceEditor; import io.github.dsheirer.gui.preference.calibration.VectorCalibrationPreferenceEditor;
@@ -40,8 +38,7 @@ import javafx.scene.Node;
*/ */
public class PreferenceEditorFactory public class PreferenceEditorFactory
{ {
public static Node getEditor(PreferenceEditorType preferenceEditorType, UserPreferences userPreferences, public static Node getEditor(PreferenceEditorType preferenceEditorType, UserPreferences userPreferences)
DatabaseManager databaseManager)
{ {
switch(preferenceEditorType) switch(preferenceEditorType)
{ {
@@ -57,8 +54,6 @@ public class PreferenceEditorFactory
return new PlaybackPreferenceEditor(userPreferences); return new PlaybackPreferenceEditor(userPreferences);
case AUDIO_RECORD: case AUDIO_RECORD:
return new RecordPreferenceEditor(userPreferences); return new RecordPreferenceEditor(userPreferences);
case DATABASE:
return new DatabasePreferenceEditor(userPreferences, databaseManager);
case CHANNEL_EVENT: case CHANNEL_EVENT:
return new DecodeEventViewPreferenceEditor(userPreferences); return new DecodeEventViewPreferenceEditor(userPreferences);
case DIRECTORY: case DIRECTORY:

View File

@@ -27,7 +27,6 @@ public enum PreferenceEditorType
APPLICATION("General"), APPLICATION("General"),
APPEARANCE("Appearance"), APPEARANCE("Appearance"),
CHANNEL_EVENT("Channel Events"), CHANNEL_EVENT("Channel Events"),
DATABASE("Call Database"),
DIRECTORY("Directories"), DIRECTORY("Directories"),
JMBE_LIBRARY("JMBE Audio Library"), JMBE_LIBRARY("JMBE Audio Library"),
RADIO_REFERENCE_ALIAS_LISTS("Alias Lists"), RADIO_REFERENCE_ALIAS_LISTS("Alias Lists"),

View File

@@ -19,7 +19,6 @@
package io.github.dsheirer.gui.preference; package io.github.dsheirer.gui.preference;
import io.github.dsheirer.database.DatabaseManager;
import io.github.dsheirer.eventbus.MyEventBus; import io.github.dsheirer.eventbus.MyEventBus;
import io.github.dsheirer.gui.playlist.ViewPlaylistRequest; import io.github.dsheirer.gui.playlist.ViewPlaylistRequest;
import io.github.dsheirer.preference.UserPreferences; import io.github.dsheirer.preference.UserPreferences;
@@ -54,7 +53,6 @@ public class UserPreferencesEditor extends BorderPane
{ {
private final static Logger mLog = LoggerFactory.getLogger(UserPreferencesEditor.class); private final static Logger mLog = LoggerFactory.getLogger(UserPreferencesEditor.class);
private DatabaseManager mDatabaseManager;
private Map<PreferenceEditorType,Node> mEditors = new EnumMap<>(PreferenceEditorType.class); private Map<PreferenceEditorType,Node> mEditors = new EnumMap<>(PreferenceEditorType.class);
private UserPreferences mUserPreferences; private UserPreferences mUserPreferences;
private MenuBar mMenuBar; private MenuBar mMenuBar;
@@ -68,10 +66,9 @@ public class UserPreferencesEditor extends BorderPane
* *
* @param userPreferences to edit * @param userPreferences to edit
*/ */
public UserPreferencesEditor(UserPreferences userPreferences, DatabaseManager databaseManager) public UserPreferencesEditor(UserPreferences userPreferences)
{ {
mUserPreferences = userPreferences; mUserPreferences = userPreferences;
mDatabaseManager = databaseManager;
setTop(getMenuBar()); setTop(getMenuBar());
@@ -187,11 +184,6 @@ public class UserPreferencesEditor extends BorderPane
treeRoot.getChildren().add(cpuItem); treeRoot.getChildren().add(cpuItem);
cpuItem.setExpanded(true); cpuItem.setExpanded(true);
TreeItem<String> databaseItem = new TreeItem<>("Database");
databaseItem.getChildren().add(new TreeItem(PreferenceEditorType.DATABASE));
treeRoot.getChildren().add(databaseItem);
databaseItem.setExpanded(true);
TreeItem<String> decoderItem = new TreeItem<>("Decoder"); TreeItem<String> decoderItem = new TreeItem<>("Decoder");
decoderItem.getChildren().add(new TreeItem(PreferenceEditorType.JMBE_LIBRARY)); decoderItem.getChildren().add(new TreeItem(PreferenceEditorType.JMBE_LIBRARY));
treeRoot.getChildren().add(decoderItem); treeRoot.getChildren().add(decoderItem);
@@ -290,7 +282,7 @@ public class UserPreferencesEditor extends BorderPane
} }
else else
{ {
editor = PreferenceEditorFactory.getEditor(type, getUserPreferences(), mDatabaseManager); editor = PreferenceEditorFactory.getEditor(type, getUserPreferences());
mEditors.put(type, editor); mEditors.put(type, editor);
} }
} }

View File

@@ -47,6 +47,7 @@ public class CallManagementPreferenceEditor extends HBox
private ToggleSwitch mDetectDuplicateTalkgroups; private ToggleSwitch mDetectDuplicateTalkgroups;
private ToggleSwitch mDetectDuplicateRadios; private ToggleSwitch mDetectDuplicateRadios;
private ToggleSwitch mSuppressDuplicateListening; private ToggleSwitch mSuppressDuplicateListening;
private ToggleSwitch mSuppressDuplicateRecording;
private ToggleSwitch mSuppressDuplicateStreaming; private ToggleSwitch mSuppressDuplicateStreaming;
private ComboBox<PatchGroupStreamingOption> mPatchGroupStreamingOptionComboBox; private ComboBox<PatchGroupStreamingOption> mPatchGroupStreamingOptionComboBox;
@@ -123,6 +124,14 @@ public class CallManagementPreferenceEditor extends HBox
GridPane.setConstraints(listeningLabel, 1, row); GridPane.setConstraints(listeningLabel, 1, row);
mEditorPane.getChildren().add(listeningLabel); mEditorPane.getChildren().add(listeningLabel);
GridPane.setConstraints(getSuppressDuplicateRecording(), 0, ++row);
mEditorPane.getChildren().add(getSuppressDuplicateRecording());
Label recordingLabel = new Label("Recording");
recordingLabel.setWrapText(true);
GridPane.setConstraints(recordingLabel, 1, row);
mEditorPane.getChildren().add(recordingLabel);
GridPane.setConstraints(getSuppressDuplicateStreaming(), 0, ++row); GridPane.setConstraints(getSuppressDuplicateStreaming(), 0, ++row);
mEditorPane.getChildren().add(getSuppressDuplicateStreaming()); mEditorPane.getChildren().add(getSuppressDuplicateStreaming());
@@ -131,13 +140,6 @@ public class CallManagementPreferenceEditor extends HBox
GridPane.setConstraints(streamingLabel, 1, row); GridPane.setConstraints(streamingLabel, 1, row);
mEditorPane.getChildren().add(streamingLabel); mEditorPane.getChildren().add(streamingLabel);
Label recordingNote = new Label("Duplicate calls are recorded and listed in the call database. They " +
"are deleted after the duplicate and Do Not Monitor retention time set in the Call Database " +
"preferences.");
recordingNote.setWrapText(true);
GridPane.setConstraints(recordingNote, 0, ++row, 2, 1);
mEditorPane.getChildren().add(recordingNote);
Separator separator2 = new Separator(); Separator separator2 = new Separator();
GridPane.setHgrow(separator2, Priority.ALWAYS); GridPane.setHgrow(separator2, Priority.ALWAYS);
GridPane.setConstraints(separator2, 0, ++row, 2, 1); GridPane.setConstraints(separator2, 0, ++row, 2, 1);
@@ -197,6 +199,22 @@ public class CallManagementPreferenceEditor extends HBox
return mSuppressDuplicateListening; return mSuppressDuplicateListening;
} }
private ToggleSwitch getSuppressDuplicateRecording()
{
if(mSuppressDuplicateRecording == null)
{
mSuppressDuplicateRecording = new ToggleSwitch();
mSuppressDuplicateRecording.disableProperty()
.bind(Bindings.and(getDetectDuplicateTalkgroups().selectedProperty().not(),
getDetectDuplicateRadios().selectedProperty().not()));
mSuppressDuplicateRecording.setSelected(mPreference.isDuplicateRecordingSuppressionEnabled());
mSuppressDuplicateRecording.selectedProperty()
.addListener((observable, oldValue, newValue) -> mPreference.setDuplicateRecordingSuppressionEnabled(newValue));
}
return mSuppressDuplicateRecording;
}
private ToggleSwitch getSuppressDuplicateStreaming() private ToggleSwitch getSuppressDuplicateStreaming()
{ {
if(mSuppressDuplicateStreaming == null) if(mSuppressDuplicateStreaming == null)

View File

@@ -1,777 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.gui.preference.database;
import io.github.dsheirer.database.DatabaseConfiguration;
import io.github.dsheirer.database.DatabaseEvent;
import io.github.dsheirer.database.DatabaseManager;
import io.github.dsheirer.database.DatabaseType;
import io.github.dsheirer.database.SchemaStatus;
import io.github.dsheirer.database.ageoff.AgeOffAction;
import io.github.dsheirer.database.ageoff.AgeOffManager;
import io.github.dsheirer.database.ageoff.RetentionPeriod;
import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.preference.database.DatabasePreference;
import io.github.dsheirer.sample.Listener;
import javafx.application.Platform;
import javafx.geometry.Insets;
import javafx.scene.control.Alert;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonBar;
import javafx.scene.control.ButtonType;
import javafx.scene.control.CheckBox;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Label;
import javafx.scene.control.PasswordField;
import javafx.scene.control.ProgressIndicator;
import javafx.scene.control.ScrollPane;
import javafx.scene.control.Separator;
import javafx.scene.control.Spinner;
import javafx.scene.control.TextField;
import javafx.scene.control.TextInputDialog;
import javafx.scene.control.Tooltip;
import javafx.scene.layout.ColumnConstraints;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.scene.layout.Region;
import javafx.scene.layout.VBox;
import javafx.stage.Modality;
import javafx.stage.Window;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
/**
* Preference editor for the call database selection and the call audio age-off rules.
*
* Applying a different database asks whether to transfer the existing calls, and when the target schema already holds
* sdrtrunk calls, whether to append to it, clear it, or create a separately named schema.
*/
public class DatabasePreferenceEditor extends VBox
{
private static final int MB_PER_GB = 1024;
private final DatabasePreference mPreference;
private final DatabaseManager mDatabaseManager;
private final Listener<DatabaseEvent> mDatabaseListener = event -> Platform.runLater(this::updateStatus);
private final Label mStatusLabel = new Label();
private final ComboBox<DatabaseType> mTypeComboBox = new ComboBox<>();
private final TextField mHostField = new TextField();
private final TextField mPortField = new TextField();
private final TextField mDatabaseField = new TextField();
private final TextField mSchemaField = new TextField();
private final TextField mUserField = new TextField();
private final PasswordField mPasswordField = new PasswordField();
private final Label mLocationLabel = new Label();
private final Label mHostLabel = new Label("Host:");
private final Label mPortLabel = new Label("Port:");
private final Label mDatabaseLabel = new Label("Database:");
private final Label mUserLabel = new Label("User:");
private final Label mPasswordLabel = new Label("Password:");
private final Label mResultLabel = new Label();
private final Button mTestButton = new Button("Test Connection");
private final Button mApplyButton = new Button("Apply");
private final Button mResetButton = new Button("Reset");
private final ProgressIndicator mProgress = new ProgressIndicator();
private final CheckBox mAgeRuleCheckBox = new CheckBox("Remove calls older than");
private final Spinner<Integer> mAgeDaysSpinner = new Spinner<>(1, 36500, 30);
private final ComboBox<AgeOffAction> mAgeActionComboBox = new ComboBox<>();
private final CheckBox mSizeRuleCheckBox = new CheckBox("Remove the oldest recordings when they exceed");
private final Spinner<Integer> mSizeGBSpinner = new Spinner<>(1, 100_000, 10);
private final ComboBox<AgeOffAction> mSizeActionComboBox = new ComboBox<>();
private final ComboBox<RetentionPeriod> mRetentionComboBox = new ComboBox<>();
private final Button mRunAgeOffButton = new Button("Run Age-Off Now");
private final Label mAgeOffResultLabel = new Label();
/**
* Constructs an instance
* @param userPreferences for the database preference
* @param databaseManager to test and switch databases
*/
public DatabasePreferenceEditor(UserPreferences userPreferences, DatabaseManager databaseManager)
{
mPreference = userPreferences.getDatabasePreference();
mDatabaseManager = databaseManager;
setPadding(new Insets(10));
setSpacing(10);
VBox content = new VBox(10, createDatabasePane(), new Separator(), createAgeOffPane());
content.setPadding(new Insets(0, 10, 10, 0));
ScrollPane scrollPane = new ScrollPane(content);
scrollPane.setFitToWidth(true);
VBox.setVgrow(scrollPane, Priority.ALWAYS);
getChildren().add(scrollPane);
loadConfiguration(mPreference.getDatabaseConfiguration());
updateStatus();
if(mDatabaseManager != null)
{
mDatabaseManager.addListener(mDatabaseListener);
}
}
/**
* Deregisters from the database manager
*/
public void dispose()
{
if(mDatabaseManager != null)
{
mDatabaseManager.removeListener(mDatabaseListener);
}
}
private VBox createDatabasePane()
{
Label title = new Label("Call Database");
title.setStyle("-fx-font-weight: bold;");
Label description = new Label("sdrtrunk stores a record of each call in this database. The built-in " +
"database needs no setup. You can use a MariaDB or PostgreSQL server instead; sdrtrunk creates the " +
"schema and tables automatically. The user needs permission to create schemas and tables.");
description.setWrapText(true);
mStatusLabel.setWrapText(true);
mTypeComboBox.getItems().addAll(DatabaseType.values());
mTypeComboBox.setOnAction(event -> {
DatabaseType type = mTypeComboBox.getValue();
if(type != null)
{
DatabaseConfiguration stored = mPreference.getStoredConfiguration(type);
mPortField.setText(type.isNetwork() ? String.valueOf(stored.port()) : "");
updateFieldVisibility();
}
});
mPortField.setPrefColumnCount(6);
mSchemaField.setTooltip(new Tooltip("Lower case letters, digits and underscores, starting with a letter"));
mPasswordField.setTooltip(new Tooltip("Note: the password is stored in plain text in the sdrtrunk " +
"preferences"));
mDatabaseField.setTooltip(new Tooltip("PostgreSQL database that holds the sdrtrunk schema"));
GridPane grid = new GridPane();
grid.setHgap(10);
grid.setVgap(8);
int row = 0;
ColumnConstraints labelColumn = new ColumnConstraints();
labelColumn.setMinWidth(Region.USE_PREF_SIZE);
ColumnConstraints fieldColumn = new ColumnConstraints();
fieldColumn.setHgrow(Priority.ALWAYS);
fieldColumn.setMaxWidth(420);
grid.getColumnConstraints().addAll(labelColumn, fieldColumn);
grid.add(new Label("Type:"), 0, row);
grid.add(mTypeComboBox, 1, row++);
grid.add(mHostLabel, 0, row);
grid.add(mHostField, 1, row++);
grid.add(mPortLabel, 0, row);
grid.add(mPortField, 1, row++);
grid.add(mDatabaseLabel, 0, row);
grid.add(mDatabaseField, 1, row++);
grid.add(mUserLabel, 0, row);
grid.add(mUserField, 1, row++);
grid.add(mPasswordLabel, 0, row);
grid.add(mPasswordField, 1, row++);
grid.add(new Label("Schema:"), 0, row);
grid.add(mSchemaField, 1, row++);
grid.add(mLocationLabel, 1, row++);
mLocationLabel.setWrapText(true);
GridPane.setHgrow(mHostField, Priority.ALWAYS);
mDatabaseLabel.setText("Database Name:");
mProgress.setVisible(false);
mProgress.setPrefSize(18, 18);
mTestButton.setOnAction(event -> testConnection());
mApplyButton.setOnAction(event -> apply());
mResetButton.setTooltip(new Tooltip("Discard edits and show the database that is in use"));
mResetButton.setOnAction(event -> {
loadConfiguration(mDatabaseManager != null ? mDatabaseManager.getConfiguration() :
mPreference.getDatabaseConfiguration());
mResultLabel.setText("");
});
HBox buttons = new HBox(10, mTestButton, mApplyButton, mResetButton, mProgress);
mResultLabel.setWrapText(true);
return new VBox(8, title, description, mStatusLabel, grid, buttons, mResultLabel);
}
private VBox createAgeOffPane()
{
Label title = new Label("Call Audio Age-Off");
title.setStyle("-fx-font-weight: bold;");
Label description = new Label("Age-off rules remove calls and their recording files automatically " +
"(a minute after startup and then every 5 minutes). Calls in progress are never removed. Only " +
"recordings listed in the call database count toward the size limit. When the size rule is enabled, " +
"the status bar recordings meter shows usage against the size limit.");
description.setWrapText(true);
mAgeActionComboBox.getItems().addAll(AgeOffAction.values());
mSizeActionComboBox.getItems().addAll(AgeOffAction.values());
mAgeDaysSpinner.setEditable(true);
mAgeDaysSpinner.setPrefWidth(100);
mSizeGBSpinner.setEditable(true);
mSizeGBSpinner.setPrefWidth(100);
mAgeRuleCheckBox.setSelected(mPreference.isAgeRuleEnabled());
mAgeDaysSpinner.getValueFactory().setValue(mPreference.getAgeRuleDays());
mAgeActionComboBox.setValue(mPreference.getAgeRuleAction());
mSizeRuleCheckBox.setSelected(mPreference.isSizeRuleEnabled());
mSizeGBSpinner.getValueFactory().setValue(Math.max(1, mPreference.getSizeRuleLimitMB() / MB_PER_GB));
mSizeActionComboBox.setValue(mPreference.getSizeRuleAction());
mAgeRuleCheckBox.selectedProperty().addListener((obs, old, selected) -> {
mPreference.setAgeRuleEnabled(selected);
updateAgeOffControls();
});
mAgeDaysSpinner.valueProperty().addListener((obs, old, value) -> {
if(value != null)
{
mPreference.setAgeRuleDays(value);
}
});
mAgeActionComboBox.valueProperty().addListener((obs, old, value) -> {
if(value != null)
{
mPreference.setAgeRuleAction(value);
}
});
mSizeRuleCheckBox.selectedProperty().addListener((obs, old, selected) -> {
mPreference.setSizeRuleEnabled(selected);
updateAgeOffControls();
});
mSizeGBSpinner.valueProperty().addListener((obs, old, value) -> {
if(value != null)
{
mPreference.setSizeRuleLimitMB(value * MB_PER_GB);
}
});
mSizeActionComboBox.valueProperty().addListener((obs, old, value) -> {
if(value != null)
{
mPreference.setSizeRuleAction(value);
}
});
mRetentionComboBox.getItems().addAll(RetentionPeriod.values());
mRetentionComboBox.setValue(mPreference.getDuplicateDoNotMonitorRetention());
mRetentionComboBox.valueProperty().addListener((obs, old, value) -> {
if(value != null)
{
mPreference.setDuplicateDoNotMonitorRetention(value);
updateAgeOffControls();
}
});
Label retentionLabel = new Label("Delete duplicate and Do Not Monitor calls after");
Label retentionNote = new Label("Deletes the call and its recording. A Do Not Monitor call is kept when " +
"an alias of the call has the Record option.");
retentionNote.setWrapText(true);
GridPane grid = new GridPane();
grid.setHgap(10);
grid.setVgap(8);
ColumnConstraints ruleColumn = new ColumnConstraints();
ruleColumn.setMinWidth(Region.USE_PREF_SIZE);
grid.getColumnConstraints().add(ruleColumn);
grid.add(retentionLabel, 0, 0);
grid.add(mRetentionComboBox, 1, 0, 2, 1);
grid.add(retentionNote, 0, 1, 3, 1);
grid.add(mAgeRuleCheckBox, 0, 2);
grid.add(new HBox(6, mAgeDaysSpinner, new Label("days")), 1, 2);
grid.add(mAgeActionComboBox, 2, 2);
grid.add(mSizeRuleCheckBox, 0, 3);
grid.add(new HBox(6, mSizeGBSpinner, new Label("GB")), 1, 3);
grid.add(mSizeActionComboBox, 2, 3);
mRunAgeOffButton.setOnAction(event -> runAgeOff());
mAgeOffResultLabel.setWrapText(true);
updateAgeOffControls();
return new VBox(8, title, description, grid, new HBox(10, mRunAgeOffButton, mAgeOffResultLabel));
}
private void updateAgeOffControls()
{
mAgeDaysSpinner.setDisable(!mAgeRuleCheckBox.isSelected());
mAgeActionComboBox.setDisable(!mAgeRuleCheckBox.isSelected());
mSizeGBSpinner.setDisable(!mSizeRuleCheckBox.isSelected());
mSizeActionComboBox.setDisable(!mSizeRuleCheckBox.isSelected());
RetentionPeriod retention = mRetentionComboBox.getValue();
mRunAgeOffButton.setDisable(mDatabaseManager == null || ((retention == null || !retention.isEnabled()) &&
!mAgeRuleCheckBox.isSelected() && !mSizeRuleCheckBox.isSelected()));
}
private void runAgeOff()
{
if(mDatabaseManager == null)
{
return;
}
if(!confirm("Run Age-Off", "Apply the enabled age-off rules now?",
"Calls and recording files that the rules select are deleted permanently."))
{
return;
}
mRunAgeOffButton.setDisable(true);
mAgeOffResultLabel.setText("Running ...");
mDatabaseManager.getAgeOffManager().runNow().whenComplete((result, error) -> Platform.runLater(() -> {
updateAgeOffControls();
if(error != null)
{
mAgeOffResultLabel.setText("Error: " + getMessage(error));
}
else
{
mAgeOffResultLabel.setText("Removed " + result.calls() + " calls and " + result.recordings() +
" recordings (" + (result.bytes() / AgeOffManager.BYTES_PER_MB) + " MB)");
}
}));
}
/**
* Shows the configuration in the editor fields.
*/
private void loadConfiguration(DatabaseConfiguration configuration)
{
DatabaseConfiguration network = configuration.type().isNetwork() ? configuration :
mPreference.getStoredConfiguration(DatabaseType.MARIADB);
mTypeComboBox.setValue(configuration.type());
mHostField.setText(network.host());
mPortField.setText(configuration.type().isNetwork() ? String.valueOf(configuration.port()) : "");
mDatabaseField.setText(network.database());
mUserField.setText(network.user());
mPasswordField.setText(network.password());
mSchemaField.setText(configuration.schema());
updateFieldVisibility();
}
private void updateFieldVisibility()
{
DatabaseType type = mTypeComboBox.getValue();
boolean network = type != null && type.isNetwork();
boolean database = type != null && type.requiresDatabaseName();
for(javafx.scene.Node node: new javafx.scene.Node[]{mHostLabel, mHostField, mPortLabel, mPortField, mUserLabel,
mUserField, mPasswordLabel, mPasswordField})
{
node.setVisible(network);
node.setManaged(network);
}
mDatabaseLabel.setVisible(database);
mDatabaseLabel.setManaged(database);
mDatabaseField.setVisible(database);
mDatabaseField.setManaged(database);
if(!network && mDatabaseManager != null)
{
mLocationLabel.setText("Database files: " + mDatabaseManager.getDatabaseDirectory());
mLocationLabel.setVisible(true);
mLocationLabel.setManaged(true);
}
else
{
mLocationLabel.setVisible(false);
mLocationLabel.setManaged(false);
}
}
private void updateStatus()
{
if(mDatabaseManager == null)
{
mStatusLabel.setText("Call database is not available");
return;
}
if(mDatabaseManager.isConnected())
{
mStatusLabel.setText("In use: " + mDatabaseManager.getConfiguration().getDescription());
mStatusLabel.setStyle("");
}
else
{
mStatusLabel.setText("Not connected: " + mDatabaseManager.getConfiguration().getDescription() +
(mDatabaseManager.getErrorMessage() != null ? " - " + mDatabaseManager.getErrorMessage() : "") +
"\nCalls are still recorded and are stored when the database becomes available.");
mStatusLabel.setStyle("-fx-text-fill: #d9534f;");
}
}
/**
* Creates a configuration from the editor fields.
* @return configuration, or null if the fields are invalid (the problem is shown to the user)
*/
private DatabaseConfiguration getEditedConfiguration()
{
DatabaseType type = mTypeComboBox.getValue();
if(type == null)
{
showResult("Select a database", true);
return null;
}
int port = 0;
if(type.isNetwork())
{
try
{
port = Integer.parseInt(mPortField.getText().trim());
}
catch(NumberFormatException nfe)
{
showResult("Port must be a number", true);
return null;
}
}
DatabaseConfiguration configuration = new DatabaseConfiguration(type, mHostField.getText(), port,
mDatabaseField.getText(), mSchemaField.getText(), mUserField.getText(), mPasswordField.getText());
String problem = configuration.validate();
if(problem != null)
{
showResult(problem, true);
return null;
}
return configuration;
}
private void showResult(String text, boolean error)
{
mResultLabel.setText(text);
mResultLabel.setStyle(error ? "-fx-text-fill: #d9534f;" : "");
}
private void setBusy(boolean busy)
{
mProgress.setVisible(busy);
mTestButton.setDisable(busy);
mApplyButton.setDisable(busy);
mResetButton.setDisable(busy);
}
private void testConnection()
{
DatabaseConfiguration configuration = getEditedConfiguration();
if(configuration == null || mDatabaseManager == null)
{
return;
}
setBusy(true);
showResult("Connecting ...", false);
mDatabaseManager.probe(configuration).whenComplete((result, error) -> Platform.runLater(() -> {
setBusy(false);
if(error != null)
{
showResult("Connection failed: " + getMessage(error), true);
}
else
{
showResult("Connection successful. " + describe(configuration, result), false);
}
}));
}
private static String describe(DatabaseConfiguration configuration, DatabaseManager.ProbeResult result)
{
return switch(result.status())
{
case MISSING -> "Schema [" + configuration.schema() + "] doesn't exist and will be created.";
case EMPTY -> "Schema [" + configuration.schema() + "] exists and the sdrtrunk tables will be created in it.";
case SDRTRUNK -> "Schema [" + configuration.schema() + "] has sdrtrunk tables with " + result.callCount() +
" calls.";
};
}
/**
* Applies the edited database selection.
*/
private void apply()
{
DatabaseConfiguration target = getEditedConfiguration();
if(target == null || mDatabaseManager == null)
{
return;
}
DatabaseConfiguration current = mDatabaseManager.getConfiguration();
if(target.equals(current) && mDatabaseManager.isConnected())
{
showResult("This database is already in use.", false);
return;
}
setBusy(true);
showResult("Connecting ...", false);
mDatabaseManager.probe(target).whenComplete((result, error) -> Platform.runLater(() -> {
if(error != null)
{
setBusy(false);
showResult("Connection failed: " + getMessage(error), true);
return;
}
//Same database and schema, for example a changed password: reconnect without moving any calls
if(target.isSameLocation(current))
{
startSwitch(target, DatabaseManager.ExistingSchemaOption.APPEND, false);
return;
}
chooseSchemaOption(target, result);
}));
}
/**
* Asks how to treat an existing sdrtrunk schema in the target database, then continues with the transfer question.
*/
private void chooseSchemaOption(DatabaseConfiguration target, DatabaseManager.ProbeResult result)
{
if(result.status() != SchemaStatus.SDRTRUNK)
{
chooseTransfer(target, DatabaseManager.ExistingSchemaOption.APPEND);
return;
}
ButtonType append = new ButtonType("Append", ButtonBar.ButtonData.YES);
ButtonType clear = new ButtonType("Clear", ButtonBar.ButtonData.OTHER);
ButtonType separate = new ButtonType("Create Separate Schema", ButtonBar.ButtonData.OTHER);
ButtonType cancel = new ButtonType("Cancel", ButtonBar.ButtonData.CANCEL_CLOSE);
Alert alert = new Alert(Alert.AlertType.CONFIRMATION, "", append, clear, separate, cancel);
alert.initOwner(getWindow());
alert.initModality(Modality.WINDOW_MODAL);
alert.setTitle("Existing sdrtrunk Schema");
alert.setHeaderText("Schema [" + target.schema() + "] already has sdrtrunk tables with " + result.callCount() +
" calls");
alert.setContentText("Append: keep the existing calls and add new calls to them.\n\n" +
"Clear: delete the existing calls and start with an empty schema. Recording files are not deleted.\n\n" +
"Create Separate Schema: leave this schema as it is and use a new schema with a different name.");
alert.getDialogPane().setMinWidth(560);
Optional<ButtonType> choice = alert.showAndWait();
if(choice.isEmpty() || choice.get() == cancel)
{
setBusy(false);
showResult("Cancelled", false);
}
else if(choice.get() == append)
{
chooseTransfer(target, DatabaseManager.ExistingSchemaOption.APPEND);
}
else if(choice.get() == clear)
{
if(confirm("Clear Schema", "Delete all " + result.callCount() + " calls in schema [" + target.schema() +
"]?", "This can't be undone."))
{
chooseTransfer(target, DatabaseManager.ExistingSchemaOption.CLEAR);
}
else
{
setBusy(false);
showResult("Cancelled", false);
}
}
else
{
chooseSeparateSchema(target, result.suggestedSchema());
}
}
/**
* Asks for the name of a separate schema and checks that it doesn't exist.
*/
private void chooseSeparateSchema(DatabaseConfiguration target, String suggestion)
{
TextInputDialog dialog = new TextInputDialog(suggestion);
dialog.initOwner(getWindow());
dialog.setTitle("Create Separate Schema");
dialog.setHeaderText("Name for the new schema");
dialog.setContentText("Schema:");
Optional<String> name = dialog.showAndWait();
if(name.isEmpty())
{
setBusy(false);
showResult("Cancelled", false);
return;
}
String schema = name.get().trim().toLowerCase();
if(!DatabaseConfiguration.isValidSchemaName(schema))
{
showError("Invalid Schema Name", "Schema names start with a letter and contain only lower case letters, " +
"digits and underscores (max 63 characters).");
chooseSeparateSchema(target, suggestion);
return;
}
DatabaseConfiguration separate = target.withSchema(schema);
mDatabaseManager.schemaExists(target, schema).whenComplete((exists, error) -> Platform.runLater(() -> {
if(error != null)
{
setBusy(false);
showResult("Error: " + getMessage(error), true);
}
else if(exists)
{
showError("Schema Exists", "Schema [" + schema + "] already exists. Choose a different name.");
chooseSeparateSchema(target, suggestion);
}
else
{
mSchemaField.setText(schema);
chooseTransfer(separate, DatabaseManager.ExistingSchemaOption.APPEND);
}
}));
}
/**
* Asks whether to transfer the calls from the current database, then switches.
*/
private void chooseTransfer(DatabaseConfiguration target, DatabaseManager.ExistingSchemaOption option)
{
CompletableFuture<Long> countFuture = CompletableFuture.supplyAsync(() -> {
try
{
return mDatabaseManager.isConnected() ? mDatabaseManager.getDatabase().getCallCount() : 0L;
}
catch(Exception e)
{
return 0L;
}
});
countFuture.whenComplete((count, error) -> Platform.runLater(() -> {
long calls = count != null ? count : 0;
if(calls <= 0)
{
startSwitch(target, option, false);
return;
}
ButtonType transfer = new ButtonType("Transfer", ButtonBar.ButtonData.YES);
ButtonType skip = new ButtonType("Don't Transfer", ButtonBar.ButtonData.NO);
ButtonType cancel = new ButtonType("Cancel", ButtonBar.ButtonData.CANCEL_CLOSE);
Alert alert = new Alert(Alert.AlertType.CONFIRMATION, "", transfer, skip, cancel);
alert.initOwner(getWindow());
alert.initModality(Modality.WINDOW_MODAL);
alert.setTitle("Transfer Calls");
alert.setHeaderText("Transfer your existing calls to the new database?");
alert.setContentText("Copy the " + calls + " calls in " + mDatabaseManager.getConfiguration()
.getDescription() + " to " + target.getDescription() + ".\n\nThe calls are copied; the current " +
"database isn't changed." + (option == DatabaseManager.ExistingSchemaOption.APPEND ?
" Calls that already exist in the new database are skipped." : ""));
alert.getDialogPane().setMinWidth(560);
Optional<ButtonType> choice = alert.showAndWait();
if(choice.isEmpty() || choice.get() == cancel)
{
setBusy(false);
showResult("Cancelled", false);
}
else
{
startSwitch(target, option, choice.get() == transfer);
}
}));
}
private void startSwitch(DatabaseConfiguration target, DatabaseManager.ExistingSchemaOption option,
boolean transfer)
{
setBusy(true);
showResult("Switching ...", false);
mDatabaseManager.switchDatabase(target, option, transfer,
status -> Platform.runLater(() -> showResult(status, false)))
.whenComplete((result, error) -> Platform.runLater(() -> {
setBusy(false);
if(error != null)
{
showResult("Unable to switch databases: " + getMessage(error) + "\nThe current database is " +
"still in use.", true);
}
else
{
loadConfiguration(target);
showResult("Now using " + target.getDescription() + (transfer ? ". Transferred " +
result.transferred() + " calls" + (result.skipped() > 0 ? ", skipped " + result.skipped() +
" calls that already existed or were in progress" : "") + "." : "."), false);
}
updateStatus();
}));
}
private boolean confirm(String title, String header, String content)
{
Alert alert = new Alert(Alert.AlertType.CONFIRMATION, content, ButtonType.OK, ButtonType.CANCEL);
alert.initOwner(getWindow());
alert.setTitle(title);
alert.setHeaderText(header);
return alert.showAndWait().filter(button -> button == ButtonType.OK).isPresent();
}
private void showError(String title, String content)
{
Alert alert = new Alert(Alert.AlertType.ERROR, content, ButtonType.OK);
alert.initOwner(getWindow());
alert.setTitle(title);
alert.setHeaderText(null);
alert.showAndWait();
}
private Window getWindow()
{
return getScene() != null ? getScene().getWindow() : null;
}
private static String getMessage(Throwable error)
{
Throwable cause = error instanceof CompletionException && error.getCause() != null ? error.getCause() : error;
return cause.getMessage() != null ? cause.getMessage() : cause.getClass().getSimpleName();
}
}

View File

@@ -33,8 +33,6 @@ import javafx.scene.control.Button;
import javafx.scene.control.ComboBox; import javafx.scene.control.ComboBox;
import javafx.scene.control.Label; import javafx.scene.control.Label;
import javafx.scene.control.Separator; import javafx.scene.control.Separator;
import javafx.scene.control.Spinner;
import javafx.scene.control.Tooltip;
import javafx.scene.layout.GridPane; import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox; import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority; import javafx.scene.layout.Priority;
@@ -113,24 +111,6 @@ public class PlaybackPreferenceEditor extends HBox
mEditorPane.add(dropVolumeLabel, 3, row); mEditorPane.add(dropVolumeLabel, 3, row);
mEditorPane.add(getDropToneVolumeComboBox(), 4, row); mEditorPane.add(getDropToneVolumeComboBox(), 4, row);
mEditorPane.add(getTestDropToneButton(), 5, row); mEditorPane.add(getTestDropToneButton(), 5, row);
mEditorPane.add(new Separator(Orientation.HORIZONTAL), 0, ++row, 6, 1);
mEditorPane.add(new Label("Talkgroup Hold"), 0, ++row, 2, 1);
Label releaseLabel = new Label("Release an idle hold after");
mEditorPane.add(releaseLabel, 0, ++row, 2, 1);
Spinner<Integer> releaseSpinner = new Spinner<>(0, 1440, mPlaybackPreference.getHoldAutoReleaseMinutes());
releaseSpinner.setEditable(true);
releaseSpinner.setPrefWidth(90);
releaseSpinner.setTooltip(new Tooltip("Minutes without a call to the hold talkgroup before the hold is " +
"released automatically. 0 = never release automatically."));
releaseSpinner.valueProperty().addListener((observable, oldValue, newValue) -> {
if(newValue != null)
{
mPlaybackPreference.setHoldAutoReleaseMinutes(newValue);
}
});
mEditorPane.add(releaseSpinner, 2, row);
mEditorPane.add(new Label("minutes (0 = never)"), 3, row, 2, 1);
} }
return mEditorPane; return mEditorPane;

View File

@@ -26,7 +26,6 @@ import io.github.dsheirer.record.RecordFormat;
import javafx.beans.value.ChangeListener; import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue; import javafx.beans.value.ObservableValue;
import javafx.geometry.Insets; import javafx.geometry.Insets;
import javafx.scene.control.CheckBox;
import javafx.scene.control.ComboBox; import javafx.scene.control.ComboBox;
import javafx.scene.control.Label; import javafx.scene.control.Label;
import javafx.scene.control.Tooltip; import javafx.scene.control.Tooltip;
@@ -72,19 +71,6 @@ public class RecordPreferenceEditor extends HBox
Label basebandLabel = new Label("Baseband I/Q Recording Format:"); Label basebandLabel = new Label("Baseband I/Q Recording Format:");
mEditorPane.add(basebandLabel, 0, 1); mEditorPane.add(basebandLabel, 0, 1);
mEditorPane.add(getBasebandRecordFormatComboBox(), 1, 1); mEditorPane.add(getBasebandRecordFormatComboBox(), 1, 1);
CheckBox recordAll = new CheckBox("Record all calls");
recordAll.setSelected(mRecordPreference.isRecordAllCalls());
recordAll.selectedProperty().addListener((observable, oldValue, selected) ->
mRecordPreference.setRecordAllCalls(selected));
mEditorPane.add(recordAll, 0, 2, 2, 1);
Label recordAllNote = new Label("Records the audio of every call. When off, only calls with an alias " +
"that has the Record option are recorded. Duplicate and Do Not Monitor calls are deleted after the " +
"retention time set in the Call Database preferences. Use the Call Database age-off rules to limit " +
"the disk space used by recordings.");
recordAllNote.setWrapText(true);
recordAllNote.setMaxWidth(560);
mEditorPane.add(recordAllNote, 0, 3, 2, 1);
} }
return mEditorPane; return mEditorPane;

View File

@@ -33,7 +33,7 @@ import io.github.dsheirer.module.decode.p25.audio.P25P2AudioModule;
import io.github.dsheirer.module.decode.p25.phase2.enumeration.ScrambleParameters; import io.github.dsheirer.module.decode.p25.phase2.enumeration.ScrambleParameters;
import io.github.dsheirer.module.decode.p25.phase2.message.P25P2Message; import io.github.dsheirer.module.decode.p25.phase2.message.P25P2Message;
import io.github.dsheirer.preference.UserPreferences; import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.call.CallManager; import io.github.dsheirer.record.AudioRecordingManager;
import io.github.dsheirer.record.binary.BinaryReader; import io.github.dsheirer.record.binary.BinaryReader;
import io.github.dsheirer.sample.Listener; import io.github.dsheirer.sample.Listener;
import java.io.IOException; import java.io.IOException;
@@ -202,7 +202,7 @@ public class P25P2MessageFramer extends C4FMMessageFramer
// alias.addAliasID(new Talkgroup(Protocol.APCO25, 11857)); // alias.addAliasID(new Talkgroup(Protocol.APCO25, 11857));
// alias.addAliasID(new Talkgroup(Protocol.APCO25, 12601)); // alias.addAliasID(new Talkgroup(Protocol.APCO25, 12601));
// aliasList.addAlias(alias); // aliasList.addAlias(alias);
CallManager recordingManager = new CallManager(userPreferences, null); AudioRecordingManager recordingManager = new AudioRecordingManager(userPreferences);
recordingManager.start(); recordingManager.start();
ProcessingChain processingChain = new ProcessingChain(channel, new AliasModel()); ProcessingChain processingChain = new ProcessingChain(channel, new AliasModel());

View File

@@ -21,7 +21,6 @@ package io.github.dsheirer.monitor;
import io.github.dsheirer.log.LoggingSuppressor; import io.github.dsheirer.log.LoggingSuppressor;
import io.github.dsheirer.preference.UserPreferences; import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.preference.database.DatabasePreference;
import io.github.dsheirer.util.ThreadPool; import io.github.dsheirer.util.ThreadPool;
import java.io.IOException; import java.io.IOException;
import java.lang.management.ManagementFactory; import java.lang.management.ManagementFactory;
@@ -57,9 +56,8 @@ public class ResourceMonitor
{ {
private static final Logger sLog = LoggerFactory.getLogger(ResourceMonitor.class); private static final Logger sLog = LoggerFactory.getLogger(ResourceMonitor.class);
private static final LoggingSuppressor sLogSuppressor = new LoggingSuppressor(sLog); private static final LoggingSuppressor sLogSuppressor = new LoggingSuppressor(sLog);
private static final long SCALOR_MEGABYTE = 1024L * 1024L; private static final int SCALOR_MEGABYTE = 1024 * 1024;
private UserPreferences mUserPreferences; private UserPreferences mUserPreferences;
private volatile DatabasePreference mDatabasePreference;
private ScheduledFuture<?> mMemoryCpuMonitorFuture; private ScheduledFuture<?> mMemoryCpuMonitorFuture;
private ScheduledFuture<?> mStorageMonitorFuture; private ScheduledFuture<?> mStorageMonitorFuture;
private LongProperty mMemoryTotal = new SimpleLongProperty(); private LongProperty mMemoryTotal = new SimpleLongProperty();
@@ -110,14 +108,6 @@ public class ResourceMonitor
} }
} }
/**
* Sets the call database preference so that the recordings usage meter can use the size age-off rule limit.
*/
public void setDatabasePreference(DatabasePreference databasePreference)
{
mDatabasePreference = databasePreference;
}
/** /**
* Stops resource monitoring. * Stops resource monitoring.
*/ */
@@ -169,14 +159,6 @@ public class ResourceMonitor
long thresholdEventLog = mUserPreferences.getDirectoryPreference().getDirectoryMaxUsageEventLogs() * SCALOR_MEGABYTE; long thresholdEventLog = mUserPreferences.getDirectoryPreference().getDirectoryMaxUsageEventLogs() * SCALOR_MEGABYTE;
long thresholdRecording = mUserPreferences.getDirectoryPreference().getDirectoryMaxUsageRecordings() * SCALOR_MEGABYTE; long thresholdRecording = mUserPreferences.getDirectoryPreference().getDirectoryMaxUsageRecordings() * SCALOR_MEGABYTE;
//When the call audio size age-off rule is enabled, the recordings meter shows usage against the rule's limit
DatabasePreference databasePreference = mDatabasePreference;
if(databasePreference != null && databasePreference.isSizeRuleEnabled())
{
thresholdRecording = databasePreference.getSizeRuleLimitMB() * SCALOR_MEGABYTE;
}
Path recordingPath = mUserPreferences.getDirectoryPreference().getDirectoryRecording(); Path recordingPath = mUserPreferences.getDirectoryPreference().getDirectoryRecording();
Path eventLogsPath = mUserPreferences.getDirectoryPreference().getDirectoryEventLog(); Path eventLogsPath = mUserPreferences.getDirectoryPreference().getDirectoryEventLog();

View File

@@ -26,7 +26,6 @@ public enum PreferenceType
{ {
APPLICATION, APPLICATION,
CALIBRATION, CALIBRATION,
DATABASE,
DECODE_EVENT, DECODE_EVENT,
DIRECTORY, DIRECTORY,
DUPLICATE_CALL_DETECTION, DUPLICATE_CALL_DETECTION,

View File

@@ -22,7 +22,6 @@ package io.github.dsheirer.preference;
import io.github.dsheirer.eventbus.MyEventBus; import io.github.dsheirer.eventbus.MyEventBus;
import io.github.dsheirer.preference.application.ApplicationPreference; import io.github.dsheirer.preference.application.ApplicationPreference;
import io.github.dsheirer.preference.calibration.VectorCalibrationPreference; import io.github.dsheirer.preference.calibration.VectorCalibrationPreference;
import io.github.dsheirer.preference.database.DatabasePreference;
import io.github.dsheirer.preference.decoder.JmbeLibraryPreference; import io.github.dsheirer.preference.decoder.JmbeLibraryPreference;
import io.github.dsheirer.preference.directory.DirectoryPreference; import io.github.dsheirer.preference.directory.DirectoryPreference;
import io.github.dsheirer.preference.duplicate.CallManagementPreference; import io.github.dsheirer.preference.duplicate.CallManagementPreference;
@@ -75,7 +74,6 @@ public class UserPreferences implements Listener<PreferenceType>
private VectorCalibrationPreference mVectorCalibrationPreference; private VectorCalibrationPreference mVectorCalibrationPreference;
private SwingPreference mSwingPreference = new SwingPreference(); private SwingPreference mSwingPreference = new SwingPreference();
private DatabasePreference mDatabasePreference;
private JavaFxPreferences mJavaFxPreferences = new JavaFxPreferences(); private JavaFxPreferences mJavaFxPreferences = new JavaFxPreferences();
/** /**
@@ -113,15 +111,7 @@ public class UserPreferences implements Listener<PreferenceType>
} }
/** /**
* Call database and age-off preferences * Decode Event preferences
*/
public DatabasePreference getDatabasePreference()
{
return mDatabasePreference;
}
/**
* Decode event preferences
*/ */
public DecodeEventPreference getDecodeEventPreference() public DecodeEventPreference getDecodeEventPreference()
{ {
@@ -241,7 +231,6 @@ public class UserPreferences implements Listener<PreferenceType>
{ {
mApplicationPreference = new ApplicationPreference(this::receive); mApplicationPreference = new ApplicationPreference(this::receive);
mChannelMultiFrequencyPreference = new ChannelMultiFrequencyPreference(this::receive); mChannelMultiFrequencyPreference = new ChannelMultiFrequencyPreference(this::receive);
mDatabasePreference = new DatabasePreference(this::receive);
mDecodeEventPreference = new DecodeEventPreference(this::receive); mDecodeEventPreference = new DecodeEventPreference(this::receive);
mDirectoryPreference = new DirectoryPreference(this::receive); mDirectoryPreference = new DirectoryPreference(this::receive);
mCallManagementPreference = new CallManagementPreference(this::receive); mCallManagementPreference = new CallManagementPreference(this::receive);

View File

@@ -1,240 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.preference.database;
import io.github.dsheirer.database.DatabaseConfiguration;
import io.github.dsheirer.database.DatabaseType;
import io.github.dsheirer.database.ageoff.AgeOffAction;
import io.github.dsheirer.database.ageoff.RetentionPeriod;
import io.github.dsheirer.preference.Preference;
import io.github.dsheirer.preference.PreferenceType;
import io.github.dsheirer.sample.Listener;
import java.util.prefs.Preferences;
/**
* Call database selection and call audio age-off rule preferences.
*
* Note: the network database password is stored in plain text in the Java preferences store.
*/
public class DatabasePreference extends Preference
{
private static final String KEY_TYPE = "database.type";
private static final String KEY_HOST = "database.host";
private static final String KEY_PORT = "database.port";
private static final String KEY_DATABASE = "database.name";
private static final String KEY_SCHEMA = "database.schema";
private static final String KEY_USER = "database.user";
private static final String KEY_PASSWORD = "database.password";
private static final String KEY_AGE_RULE_ENABLED = "ageoff.age.enabled";
private static final String KEY_AGE_RULE_DAYS = "ageoff.age.days";
private static final String KEY_AGE_RULE_ACTION = "ageoff.age.action";
private static final String KEY_SIZE_RULE_ENABLED = "ageoff.size.enabled";
private static final String KEY_SIZE_RULE_LIMIT_MB = "ageoff.size.limit.mb";
private static final String KEY_SIZE_RULE_ACTION = "ageoff.size.action";
private static final String KEY_DUPLICATE_DNM_RETENTION = "ageoff.duplicate.dnm.retention";
public static final String DEFAULT_POSTGRES_DATABASE = "postgres";
public static final int DEFAULT_AGE_DAYS = 30;
public static final int DEFAULT_SIZE_LIMIT_MB = 10 * 1024;
private final Preferences mPreferences = Preferences.userNodeForPackage(DatabasePreference.class);
/**
* Constructs an instance
* @param updateListener to receive notifications whenever these preferences change
*/
public DatabasePreference(Listener<PreferenceType> updateListener)
{
super(updateListener);
}
@Override
public PreferenceType getPreferenceType()
{
return PreferenceType.DATABASE;
}
/**
* Currently selected call database. Defaults to the built-in H2 database.
*/
public DatabaseConfiguration getDatabaseConfiguration()
{
DatabaseType type;
try
{
type = DatabaseType.valueOf(mPreferences.get(KEY_TYPE, DatabaseType.H2.name()));
}
catch(IllegalArgumentException iae)
{
type = DatabaseType.H2;
}
return new DatabaseConfiguration(type, mPreferences.get(KEY_HOST, "localhost"),
mPreferences.getInt(KEY_PORT, type.getDefaultPort()),
type.requiresDatabaseName() ? mPreferences.get(KEY_DATABASE, DEFAULT_POSTGRES_DATABASE) : "",
mPreferences.get(KEY_SCHEMA, DatabaseConfiguration.DEFAULT_SCHEMA),
mPreferences.get(KEY_USER, ""), mPreferences.get(KEY_PASSWORD, ""));
}
/**
* Stores the selected call database. The database manager applies the change; this only persists it.
*/
public void setDatabaseConfiguration(DatabaseConfiguration configuration)
{
mPreferences.put(KEY_TYPE, configuration.type().name());
mPreferences.put(KEY_SCHEMA, configuration.schema());
if(configuration.type().isNetwork())
{
mPreferences.put(KEY_HOST, configuration.host());
mPreferences.putInt(KEY_PORT, configuration.port());
mPreferences.put(KEY_USER, configuration.user());
mPreferences.put(KEY_PASSWORD, configuration.password());
}
if(configuration.type().requiresDatabaseName())
{
mPreferences.put(KEY_DATABASE, configuration.database());
}
notifyPreferenceUpdated();
}
/**
* Last used network settings for the database type, used to pre-fill the editor when the user switches types.
*/
public DatabaseConfiguration getStoredConfiguration(DatabaseType type)
{
DatabaseConfiguration current = getDatabaseConfiguration();
int port = current.type() == type ? current.port() : type.getDefaultPort();
return new DatabaseConfiguration(type, mPreferences.get(KEY_HOST, "localhost"), port,
type.requiresDatabaseName() ? mPreferences.get(KEY_DATABASE, DEFAULT_POSTGRES_DATABASE) : "",
current.schema(),
mPreferences.get(KEY_USER, ""), mPreferences.get(KEY_PASSWORD, ""));
}
public boolean isAgeRuleEnabled()
{
return mPreferences.getBoolean(KEY_AGE_RULE_ENABLED, false);
}
public void setAgeRuleEnabled(boolean enabled)
{
mPreferences.putBoolean(KEY_AGE_RULE_ENABLED, enabled);
notifyPreferenceUpdated();
}
/**
* Maximum call age in days for the age rule
*/
public int getAgeRuleDays()
{
return Math.max(1, mPreferences.getInt(KEY_AGE_RULE_DAYS, DEFAULT_AGE_DAYS));
}
public void setAgeRuleDays(int days)
{
mPreferences.putInt(KEY_AGE_RULE_DAYS, Math.max(1, days));
notifyPreferenceUpdated();
}
public AgeOffAction getAgeRuleAction()
{
return getAction(KEY_AGE_RULE_ACTION);
}
public void setAgeRuleAction(AgeOffAction action)
{
mPreferences.put(KEY_AGE_RULE_ACTION, action.name());
notifyPreferenceUpdated();
}
public boolean isSizeRuleEnabled()
{
return mPreferences.getBoolean(KEY_SIZE_RULE_ENABLED, false);
}
public void setSizeRuleEnabled(boolean enabled)
{
mPreferences.putBoolean(KEY_SIZE_RULE_ENABLED, enabled);
notifyPreferenceUpdated();
}
/**
* Maximum total size of call recordings in megabytes for the size rule
*/
public int getSizeRuleLimitMB()
{
return Math.max(1, mPreferences.getInt(KEY_SIZE_RULE_LIMIT_MB, DEFAULT_SIZE_LIMIT_MB));
}
public void setSizeRuleLimitMB(int limitMB)
{
mPreferences.putInt(KEY_SIZE_RULE_LIMIT_MB, Math.max(1, limitMB));
notifyPreferenceUpdated();
}
public AgeOffAction getSizeRuleAction()
{
return getAction(KEY_SIZE_RULE_ACTION);
}
public void setSizeRuleAction(AgeOffAction action)
{
mPreferences.put(KEY_SIZE_RULE_ACTION, action.name());
notifyPreferenceUpdated();
}
/**
* How long duplicate calls, and Do Not Monitor calls that aren't marked for recording by an alias, are kept
* before the call and its recording are deleted.
*/
public RetentionPeriod getDuplicateDoNotMonitorRetention()
{
try
{
return RetentionPeriod.valueOf(mPreferences.get(KEY_DUPLICATE_DNM_RETENTION,
RetentionPeriod.DEFAULT.name()));
}
catch(IllegalArgumentException iae)
{
return RetentionPeriod.DEFAULT;
}
}
public void setDuplicateDoNotMonitorRetention(RetentionPeriod retention)
{
mPreferences.put(KEY_DUPLICATE_DNM_RETENTION, retention.name());
notifyPreferenceUpdated();
}
private AgeOffAction getAction(String key)
{
try
{
return AgeOffAction.valueOf(mPreferences.get(key, AgeOffAction.DELETE_CALL_AND_RECORDING.name()));
}
catch(IllegalArgumentException iae)
{
return AgeOffAction.DELETE_CALL_AND_RECORDING;
}
}
}

View File

@@ -43,7 +43,6 @@ public class DirectoryPreference extends Preference
private static final String DIRECTORY_APPLICATION_ROOT = "SDRTrunk"; private static final String DIRECTORY_APPLICATION_ROOT = "SDRTrunk";
private static final String DIRECTORY_APPLICATION_LOG = "logs"; private static final String DIRECTORY_APPLICATION_LOG = "logs";
private static final String DIRECTORY_CONFIGURATION = "configuration"; private static final String DIRECTORY_CONFIGURATION = "configuration";
private static final String DIRECTORY_DATABASE = "db";
private static final String DIRECTORY_EVENT_LOG = "event_logs"; private static final String DIRECTORY_EVENT_LOG = "event_logs";
private static final String DIRECTORY_JMBE = "jmbe"; private static final String DIRECTORY_JMBE = "jmbe";
private static final String DIRECTORY_PLAYLIST = "playlist"; private static final String DIRECTORY_PLAYLIST = "playlist";
@@ -481,14 +480,6 @@ public class DirectoryPreference extends Preference
return Paths.get(System.getProperty("user.home"), DIRECTORY_APPLICATION_ROOT); return Paths.get(System.getProperty("user.home"), DIRECTORY_APPLICATION_ROOT);
} }
/**
* Built-in (H2) call database directory: the 'db' folder in the application root directory.
*/
public Path getDirectoryDatabase()
{
return getDirectoryApplicationRoot().resolve(DIRECTORY_DATABASE);
}
/** /**
* Default event logs directory * Default event logs directory
*/ */

View File

@@ -143,10 +143,7 @@ public class CallManagementPreference extends Preference implements ICallManagem
/** /**
* Preference for suppressing recording of duplicate calls. * Preference for suppressing recording of duplicate calls.
* @deprecated duplicate calls are always recorded and are deleted after the call database duplicate and Do Not
* Monitor retention time (#2742). Kept so that the stored preference value remains readable.
*/ */
@Deprecated
public boolean isDuplicateRecordingSuppressionEnabled() public boolean isDuplicateRecordingSuppressionEnabled()
{ {
if(mDuplicateRecordingSuppressionEnabled == null) if(mDuplicateRecordingSuppressionEnabled == null)
@@ -159,9 +156,7 @@ public class CallManagementPreference extends Preference implements ICallManagem
/** /**
* Sets the preference for suppressing recording of duplicate calls. * Sets the preference for suppressing recording of duplicate calls.
* @deprecated see {@link #isDuplicateRecordingSuppressionEnabled()}
*/ */
@Deprecated
public void setDuplicateRecordingSuppressionEnabled(boolean enabled) public void setDuplicateRecordingSuppressionEnabled(boolean enabled)
{ {
mPreferences.putBoolean(PREFERENCE_KEY_SUPPRESS_DUPLICATE_RECORDING, enabled); mPreferences.putBoolean(PREFERENCE_KEY_SUPPRESS_DUPLICATE_RECORDING, enabled);

View File

@@ -46,7 +46,6 @@ public class PlaybackPreference extends Preference
private static final String PREFERENCE_KEY_AUDIO_DEVICE_NAME = "audio.playback.device.name"; private static final String PREFERENCE_KEY_AUDIO_DEVICE_NAME = "audio.playback.device.name";
private static final String PREFERENCE_KEY_AUDIO_CHANNEL_COUNT = "audio.playback.channel.count"; private static final String PREFERENCE_KEY_AUDIO_CHANNEL_COUNT = "audio.playback.channel.count";
private static final String PREFERENCE_KEY_HOLD_AUTO_RELEASE_MINUTES = "audio.playback.hold.auto.release.minutes";
public static final int TONE_LENGTH_SAMPLES = 160; public static final int TONE_LENGTH_SAMPLES = 160;
private final static Logger mLog = LoggerFactory.getLogger(PlaybackPreference.class); private final static Logger mLog = LoggerFactory.getLogger(PlaybackPreference.class);
@@ -297,22 +296,4 @@ public class PlaybackPreference extends Preference
notifyPreferenceUpdated(); notifyPreferenceUpdated();
} }
} }
/**
* Minutes without a call to a hold talkgroup before the hold is released automatically, or 0 to never release
* a hold automatically.
*/
public int getHoldAutoReleaseMinutes()
{
return Math.max(0, mPreferences.getInt(PREFERENCE_KEY_HOLD_AUTO_RELEASE_MINUTES, 0));
}
/**
* Sets the hold talkgroup automatic release time in minutes (0 = never).
*/
public void setHoldAutoReleaseMinutes(int minutes)
{
mPreferences.putInt(PREFERENCE_KEY_HOLD_AUTO_RELEASE_MINUTES, Math.max(0, minutes));
notifyPreferenceUpdated();
}
} }

View File

@@ -37,7 +37,6 @@ public class RecordPreference extends Preference
private static final String PREFERENCE_KEY_AUDIO_RECORD_FORMAT = "audio.record.format"; private static final String PREFERENCE_KEY_AUDIO_RECORD_FORMAT = "audio.record.format";
private static final RecordFormat DEFAULT_RECORD_FORMAT = RecordFormat.MP3; private static final RecordFormat DEFAULT_RECORD_FORMAT = RecordFormat.MP3;
private static final String PREFERENCE_KEY_BASEBAND_RECORD_FORMAT = "baseband.record.format"; private static final String PREFERENCE_KEY_BASEBAND_RECORD_FORMAT = "baseband.record.format";
private static final String PREFERENCE_KEY_RECORD_ALL_CALLS = "audio.record.all.calls";
private static final BasebandRecordFormat DEFAULT_BASEBAND_RECORD_FORMAT = BasebandRecordFormat.WAVE; private static final BasebandRecordFormat DEFAULT_BASEBAND_RECORD_FORMAT = BasebandRecordFormat.WAVE;
private final static Logger mLog = LoggerFactory.getLogger(RecordPreference.class); private final static Logger mLog = LoggerFactory.getLogger(RecordPreference.class);
private Preferences mPreferences = Preferences.userNodeForPackage(RecordPreference.class); private Preferences mPreferences = Preferences.userNodeForPackage(RecordPreference.class);
@@ -132,22 +131,4 @@ public class RecordPreference extends Preference
mPreferences.put(PREFERENCE_KEY_BASEBAND_RECORD_FORMAT, basebandRecordFormat.name()); mPreferences.put(PREFERENCE_KEY_BASEBAND_RECORD_FORMAT, basebandRecordFormat.name());
notifyPreferenceUpdated(); notifyPreferenceUpdated();
} }
/**
* Indicates if the audio of every call is recorded. When false, only calls with an alias that has the record
* option are recorded. Default: true.
*/
public boolean isRecordAllCalls()
{
return mPreferences.getBoolean(PREFERENCE_KEY_RECORD_ALL_CALLS, true);
}
/**
* Sets whether the audio of every call is recorded
*/
public void setRecordAllCalls(boolean recordAllCalls)
{
mPreferences.putBoolean(PREFERENCE_KEY_RECORD_ALL_CALLS, recordAllCalls);
notifyPreferenceUpdated();
}
} }

View File

@@ -1,6 +1,6 @@
/* /*
* ***************************************************************************** * *****************************************************************************
* Copyright (C) 2014-2026 Dennis Sheirer * Copyright (C) 2014-2024 Dennis Sheirer
* *
* This program is free software: you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
@@ -16,11 +16,10 @@
* along with this program. If not, see <http://www.gnu.org/licenses/> * along with this program. If not, see <http://www.gnu.org/licenses/>
* **************************************************************************** * ****************************************************************************
*/ */
package io.github.dsheirer.record; package io.github.dsheirer.record;
import io.github.dsheirer.audio.AudioSegment; import io.github.dsheirer.audio.AudioSegment;
import io.github.dsheirer.database.call.CallRecord;
import io.github.dsheirer.database.call.RecordingState;
import io.github.dsheirer.identifier.Form; import io.github.dsheirer.identifier.Form;
import io.github.dsheirer.identifier.Identifier; import io.github.dsheirer.identifier.Identifier;
import io.github.dsheirer.identifier.IdentifierClass; import io.github.dsheirer.identifier.IdentifierClass;
@@ -31,243 +30,150 @@ import io.github.dsheirer.identifier.tone.Tone;
import io.github.dsheirer.identifier.tone.ToneIdentifier; import io.github.dsheirer.identifier.tone.ToneIdentifier;
import io.github.dsheirer.identifier.tone.ToneSequence; import io.github.dsheirer.identifier.tone.ToneSequence;
import io.github.dsheirer.preference.UserPreferences; import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.record.stream.IStreamingAudioWriter; import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.record.stream.StreamingMP3Writer;
import io.github.dsheirer.record.stream.StreamingWaveWriter;
import io.github.dsheirer.record.wave.AudioMetadataUtils;
import io.github.dsheirer.util.StringUtils; import io.github.dsheirer.util.StringUtils;
import io.github.dsheirer.util.ThreadPool;
import io.github.dsheirer.util.TimeStamp; import io.github.dsheirer.util.TimeStamp;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
/** /**
* Records call audio to MP3 or WAVE files while the call is in progress (streaming). * Monitors audio segments and upon completion records any audio segments that have been flagged as recordable
*
* Every call is recorded when the record all calls preference is enabled (default), otherwise only calls with an
* alias that has the record option. The recording file exists from the start of the call, and its path is stored
* with the call. The file name is fixed when the recording starts, so it contains the identifiers known at that time.
* The recording starts when the call has a TO identifier, or after one second of audio without one. The final
* metadata (ID3/LIST tags) is written when the call completes.
*
* The call manager creates one {@link Recording} per call and drives it from its call processing thread. This class
* isn't thread safe: all methods must be invoked on that thread.
*/ */
public class CallRecorder public class AudioRecordingManager implements Listener<AudioSegment>
{ {
private final static Logger mLog = LoggerFactory.getLogger(CallRecorder.class); private final static Logger mLog = LoggerFactory.getLogger(AudioRecordingManager.class);
private static final long MAX_WAIT_FOR_TO_IDENTIFIER_MS = 1000; private LinkedTransferQueue<AudioSegment> mCompletedAudioSegmentQueue = new LinkedTransferQueue<>();
private final UserPreferences mUserPreferences; private ScheduledFuture<?> mQueueProcessorHandle;
private UserPreferences mUserPreferences;
private int mUnknownAudioRecordingIndex = 1; private int mUnknownAudioRecordingIndex = 1;
private int mDuplicateAudioRecordingSuffix = 1; private int mDuplicateAudioRecordingSuffix = 1;
private String mPreviousRecordingPath = null; private String mPreviousRecordingPath = null;
/** /**
* Constructs an instance * Constructs an instance
* @param userPreferences for the recording format, record all calls and the recordings directory * @param userPreferences to determine audio recording format
*/ */
public CallRecorder(UserPreferences userPreferences) public AudioRecordingManager(UserPreferences userPreferences)
{ {
mUserPreferences = userPreferences; mUserPreferences = userPreferences;
} }
/** /**
* Creates the recording for a call. The recording starts when the call is recordable. * Starts the manager and begins audio segment recording.
*/ */
public Recording createRecording(AudioSegment audioSegment) public void start()
{ {
return new Recording(audioSegment); if(mQueueProcessorHandle == null)
{
mQueueProcessorHandle = ThreadPool.SCHEDULED.scheduleAtFixedRate(new QueueProcessor(),
0, 1, TimeUnit.SECONDS);
}
}
/**
* Stops the manager and records any remaining queued audio segments.
*/
public void stop()
{
if(mQueueProcessorHandle != null)
{
mQueueProcessorHandle.cancel(true);
processAudioSegments();
mQueueProcessorHandle = null;
}
}
/**
* Primary receive method for incoming audio segments to be recorded
*/
@Override
public void receive(AudioSegment audioSegment)
{
audioSegment.completeProperty().addListener(new AudioSegmentCompletionMonitor(audioSegment));
}
/**
* Processes audio segments that have been flagged as complete.
* @param audioSegment
*/
public void processCompletedAudioSegment(AudioSegment audioSegment)
{
//Debug
if(audioSegment.getAudioBufferCount() == 0)
{
// mLog.debug("Audio Segment detected with 0 audio buffers");
}
List<Identifier> toIdentifiers = audioSegment.getIdentifierCollection().getIdentifiers(Role.TO);
if(toIdentifiers.isEmpty())
{
// mLog.debug("Audio Segment detected with NO TO identifiers");
}
if(audioSegment.recordAudioProperty().get())
{
mCompletedAudioSegmentQueue.add(audioSegment);
}
else
{
audioSegment.decrementConsumerCount();
}
}
/**
* Processes any queued audio segments
*/
private void processAudioSegments()
{
RecordFormat recordFormat = mUserPreferences.getRecordPreference().getAudioRecordFormat();
AudioSegment audioSegment = mCompletedAudioSegmentQueue.poll();
while(audioSegment != null)
{
if(audioSegment.isDuplicate() && mUserPreferences.getCallManagementPreference().isDuplicateRecordingSuppressionEnabled())
{
audioSegment.decrementConsumerCount();
}
else
{
Path path = getAudioRecordingPath(audioSegment.getIdentifierCollection(), recordFormat);
try
{
AudioSegmentRecorder.record(audioSegment, path, recordFormat, mUserPreferences);
}
catch(IOException ioe)
{
mLog.error("Error recording audio segment to [" + path.toString() + "]");
}
audioSegment.decrementConsumerCount();
}
//Grab the next one to record
audioSegment = mCompletedAudioSegmentQueue.poll();
}
} }
/** /**
* Base path to recordings folder * Base path to recordings folder
* @return
*/ */
public Path getRecordingBasePath() public Path getRecordingBasePath()
{ {
return mUserPreferences.getDirectoryPreference().getDirectoryRecording(); return mUserPreferences.getDirectoryPreference().getDirectoryRecording();
} }
/**
* Indicates if the call is recorded: all calls when record all calls is enabled, otherwise only calls with an
* alias that has the record option. Duplicate and Do Not Monitor calls are recorded and later deleted by the
* call database retention rule.
*/
public boolean isRecordable(AudioSegment audioSegment)
{
return mUserPreferences.getRecordPreference().isRecordAllCalls() || audioSegment.recordAudioProperty().get();
}
/**
* Creates a unique recording file path for the identifiers.
*/
private Path getUniqueRecordingPath(IdentifierCollection identifierCollection, RecordFormat recordFormat)
{
Path path = getAudioRecordingPath(identifierCollection, recordFormat);
if(!Files.exists(path))
{
return path;
}
String name = path.getFileName().toString();
String base = name.substring(0, name.length() - recordFormat.getExtension().length());
for(int version = 2; version < 1000; version++)
{
Path candidate = path.resolveSibling(base + "_V" + version + recordFormat.getExtension());
if(!Files.exists(candidate))
{
return candidate;
}
}
return path.resolveSibling(base + "_" + System.nanoTime() + recordFormat.getExtension());
}
/**
* Opens a streaming writer for the recording format.
*/
private IStreamingAudioWriter createWriter(Path path, RecordFormat recordFormat, AudioSegment audioSegment)
throws IOException
{
return switch(recordFormat)
{
case MP3 -> new StreamingMP3Writer(path, mUserPreferences.getMP3Preference().getAudioSampleRate(),
mUserPreferences.getMP3Preference().getMP3Setting(),
mUserPreferences.getMP3Preference().isNormalizeAudioBeforeEncode(),
AudioMetadataUtils.getMetadataMap(audioSegment.getIdentifierCollection(), audioSegment.getAliasList()));
case WAVE -> new StreamingWaveWriter(path);
};
}
/**
* Recording of one call. It updates the recording fields of the call record (format, file path, file size and
* recording state).
*/
public class Recording
{
private final AudioSegment mAudioSegment;
private IStreamingAudioWriter mWriter;
private int mBuffersWritten;
private boolean mRecordingAttempted;
private Recording(AudioSegment audioSegment)
{
mAudioSegment = audioSegment;
}
/**
* Starts the recording when the call becomes recordable, and writes the audio received since the last update.
* @param call record to update with the recording details
*/
public void update(CallRecord call)
{
if(mWriter != null)
{
writeAudio(call);
return;
}
if(mRecordingAttempted || !isRecordable(mAudioSegment) || !mAudioSegment.hasAudio())
{
return;
}
//Give the decoder a moment to provide the TO identifier, since it is part of the file name
if(mAudioSegment.getIdentifierCollection().getToIdentifier() == null &&
mAudioSegment.getDuration() < MAX_WAIT_FOR_TO_IDENTIFIER_MS && !mAudioSegment.isComplete())
{
return;
}
mRecordingAttempted = true;
RecordFormat recordFormat = mUserPreferences.getRecordPreference().getAudioRecordFormat();
Path path = getUniqueRecordingPath(mAudioSegment.getIdentifierCollection(), recordFormat);
try
{
mWriter = createWriter(path, recordFormat, mAudioSegment);
call.setRecordFormat(recordFormat.name());
call.setFilePath(path.toAbsolutePath().toString());
call.setRecordingState(RecordingState.RECORDING);
writeAudio(call);
}
catch(IOException ioe)
{
mLog.error("Error creating audio recording [" + path + "] - " + ioe.getMessage());
mWriter = null;
call.setRecordingState(RecordingState.FAILED);
}
}
/**
* Writes the audio buffers that haven't been written yet.
*/
private void writeAudio(CallRecord call)
{
int count = mAudioSegment.getAudioBufferCount();
if(mWriter != null && mBuffersWritten < count)
{
List<float[]> buffers = new ArrayList<>(mAudioSegment.getAudioBuffers().subList(mBuffersWritten, count));
try
{
mWriter.write(buffers);
mBuffersWritten = count;
}
catch(IOException ioe)
{
mLog.error("Error writing audio recording [" + mWriter.getPath() + "] - " + ioe.getMessage());
mWriter.abort();
mWriter = null;
call.setRecordingState(RecordingState.FAILED);
}
}
}
/**
* Writes the remaining audio and the final metadata, and closes the recording. Invoke when the call
* completes.
* @param call record to update with the final recording details
*/
public void complete(CallRecord call)
{
update(call);
if(mWriter != null)
{
writeAudio(call);
if(mWriter != null)
{
Path path = mWriter.getPath();
try
{
mWriter.close(AudioMetadataUtils.getMetadataMap(mAudioSegment.getIdentifierCollection(),
mAudioSegment.getAliasList()));
call.setFileSize(Files.size(path));
call.setRecordingState(RecordingState.RECORDED);
}
catch(IOException ioe)
{
mLog.error("Error completing audio recording [" + path + "] - " + ioe.getMessage());
call.setRecordingState(Files.exists(path) ? RecordingState.RECORDED : RecordingState.FAILED);
}
mWriter = null;
}
}
}
}
/** /**
* Provides a formatted audio recording filename to use as the final audio filename. * Provides a formatted audio recording filename to use as the final audio filename.
*/ */
@@ -417,6 +323,22 @@ public class CallRecorder
* Audio segment completion monitor. Listens for the audio segment's complete flag to be set and then * Audio segment completion monitor. Listens for the audio segment's complete flag to be set and then
* queues the audio segment for recording. * queues the audio segment for recording.
*/ */
public class AudioSegmentCompletionMonitor implements ChangeListener<Boolean>
{
private AudioSegment mAudioSegment;
public AudioSegmentCompletionMonitor(AudioSegment audioSegment)
{
mAudioSegment = audioSegment;
}
@Override
public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue)
{
mAudioSegment.completeProperty().removeListener(this);
processCompletedAudioSegment(mAudioSegment);
}
}
public static String clean(String value) public static String clean(String value)
{ {
@@ -432,4 +354,23 @@ public class CallRecorder
return null; return null;
} }
/**
* Threaded queue processor to process/record each recordable audio segment
*/
public class QueueProcessor implements Runnable
{
@Override
public void run()
{
try
{
processAudioSegments();
}
catch(Throwable t)
{
mLog.error("Error while processing queued audio segments to recordings", t);
}
}
}
} }

View File

@@ -1,200 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.record;
import io.github.dsheirer.dsp.filter.resample.RealResampler;
import net.sourceforge.lame.lowlevel.LameDecoder;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.UnsupportedAudioFileException;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
/**
* Reads a call audio recording (MP3 or WAVE) as 8 kHz mono PCM samples for replay through the audio channels.
*/
public class RecordingReader
{
public static final int SAMPLE_RATE = 8000;
private RecordingReader()
{
}
/**
* Reads the recording.
* @param path of an .mp3 or .wav recording
* @return 8 kHz mono samples in the range -1.0 to 1.0
* @throws IOException if the file can't be read or decoded
*/
public static float[] read(Path path) throws IOException
{
String name = path.getFileName().toString().toLowerCase(Locale.ROOT);
if(name.endsWith(".mp3"))
{
return readMP3(path);
}
if(name.endsWith(".wav"))
{
return readWave(path);
}
throw new IOException("Unsupported recording format: " + path.getFileName());
}
private static float[] readMP3(Path path) throws IOException
{
LameDecoder decoder;
try
{
decoder = new LameDecoder(path.toAbsolutePath().toString());
}
catch(Exception e)
{
throw new IOException("Unable to open MP3 recording " + path.getFileName() + ": " + e.getMessage(), e);
}
try
{
int channels = Math.max(1, decoder.getChannels());
//The decoder reports 1152 samples per frame, but MPEG-2/2.5 frames (sample rates below 32 kHz, e.g. the
//default 16 kHz recordings) contain 576 samples, and the decoder doesn't report how many bytes it wrote.
int samplesPerFrame = decoder.getSampleRate() >= 32000 ? 1152 : 576;
int frameBytes = samplesPerFrame * channels * 2;
ByteBuffer buffer = ByteBuffer.allocate(Math.max(frameBytes, decoder.getFrameSize() * channels * 2));
ByteArrayOutputStream pcm = new ByteArrayOutputStream();
while(decoder.decode(buffer))
{
pcm.write(buffer.array(), 0, frameBytes);
buffer.clear();
}
float[] samples = toFloat(pcm.toByteArray(), channels, ByteOrder.LITTLE_ENDIAN);
return resample(samples, decoder.getSampleRate());
}
catch(RuntimeException re)
{
throw new IOException("Unable to decode MP3 recording " + path.getFileName() + ": " + re.getMessage(), re);
}
finally
{
decoder.close();
}
}
private static float[] readWave(Path path) throws IOException
{
try(AudioInputStream source = AudioSystem.getAudioInputStream(path.toFile()))
{
AudioFormat format = source.getFormat();
AudioFormat pcmFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, format.getSampleRate(), 16,
format.getChannels(), format.getChannels() * 2, format.getSampleRate(), false);
try(AudioInputStream pcm = AudioSystem.getAudioInputStream(pcmFormat, source))
{
float[] samples = toFloat(pcm.readAllBytes(), format.getChannels(), ByteOrder.LITTLE_ENDIAN);
return resample(samples, Math.round(format.getSampleRate()));
}
}
catch(UnsupportedAudioFileException e)
{
throw new IOException("Unsupported WAVE recording " + path.getFileName() + ": " + e.getMessage(), e);
}
}
/**
* Converts 16-bit PCM to mono float samples, averaging the channels.
*/
static float[] toFloat(byte[] pcm, int channels, ByteOrder order)
{
ByteBuffer buffer = ByteBuffer.wrap(pcm).order(order);
int frames = pcm.length / (2 * channels);
float[] samples = new float[frames];
for(int x = 0; x < frames; x++)
{
float sum = 0;
for(int c = 0; c < channels; c++)
{
sum += buffer.getShort() / 32768.0f;
}
samples[x] = sum / channels;
}
return samples;
}
/**
* Resamples to 8 kHz.
*/
static float[] resample(float[] samples, int sampleRate)
{
if(sampleRate == SAMPLE_RATE || samples.length == 0)
{
return samples;
}
RealResampler resampler = new RealResampler(sampleRate, SAMPLE_RATE, 4096, 512);
List<float[]> output = new ArrayList<>();
resampler.setListener(output::add);
int chunk = 4096;
for(int offset = 0; offset < samples.length; offset += chunk)
{
float[] piece = new float[Math.min(chunk, samples.length - offset)];
System.arraycopy(samples, offset, piece, 0, piece.length);
resampler.resample(piece);
}
resampler.flush();
int length = 0;
for(float[] buffer: output)
{
length += buffer.length;
}
float[] resampled = new float[length];
int position = 0;
for(float[] buffer: output)
{
System.arraycopy(buffer, 0, resampled, position, buffer.length);
position += buffer.length;
}
return resampled;
}
}

View File

@@ -1,54 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.record.stream;
import io.github.dsheirer.record.wave.AudioMetadata;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
/**
* Writes a call audio recording incrementally while the call is in progress, so that the recording file exists from
* the start of the call. The metadata (e.g. ID3 tags) is written when the recording is opened and rewritten with the
* final call metadata when the recording is closed.
*/
public interface IStreamingAudioWriter
{
/**
* Writes the next chunk of 8 kHz PCM audio. The buffers are not modified.
*/
void write(List<float[]> audioBuffers) throws IOException;
/**
* Finishes the recording with the final call metadata and closes the file.
*/
void close(Map<AudioMetadata,String> metadata) throws IOException;
/**
* Closes the file without finishing it, for example when the recording will be discarded.
*/
void abort();
/**
* Recording file
*/
Path getPath();
}

View File

@@ -1,254 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.record.stream;
import io.github.dsheirer.audio.convert.InputAudioFormat;
import io.github.dsheirer.audio.convert.MP3AudioConverter;
import io.github.dsheirer.audio.convert.MP3Setting;
import io.github.dsheirer.record.wave.AudioMetadata;
import io.github.dsheirer.record.wave.AudioMetadataUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
* Streaming MP3 recording.
*
* The ID3v2 tag has to be at the start of the file, but the final call metadata is only known when the call ends. The
* writer reserves space for the tag by writing the initial tag padded to a fixed size, and overwrites it in place with
* the final tag when the recording closes. If the final tag doesn't fit (very rare), the file is rewritten.
*
* Audio normalization: the whole-call normalization of the non-streaming recorder can't be used while the call is in
* progress. Instead the gain is derived from the peak level seen so far in the call, so the gain can only decrease
* during the call and the audio never clips. The same 0.95 target and -20 dBFS gain limit are used.
*/
public class StreamingMP3Writer implements IStreamingAudioWriter
{
private static final Logger LOGGER = LoggerFactory.getLogger(StreamingMP3Writer.class);
static final int RESERVED_TAG_SIZE = 4096;
private static final int ID3_HEADER_SIZE = 10;
private static final float NORMALIZE_TARGET = 0.95f;
private static final float NORMALIZE_MINIMUM_PEAK = 0.1f;
private final Path mPath;
private final FileChannel mFileChannel;
private final MP3AudioConverter mConverter;
private final boolean mNormalize;
private float mPeak = NORMALIZE_MINIMUM_PEAK;
/**
* Creates the recording file and writes the initial (padded) ID3 tag.
* @param path for the new file, which must not exist
* @param inputAudioFormat for the encoder
* @param mp3Setting for the encoder
* @param normalize to apply peak-tracking audio gain normalization
* @param initialMetadata known at the start of the call
*/
public StreamingMP3Writer(Path path, InputAudioFormat inputAudioFormat, MP3Setting mp3Setting, boolean normalize,
Map<AudioMetadata,String> initialMetadata) throws IOException
{
mPath = path;
mNormalize = normalize;
mConverter = new MP3AudioConverter(inputAudioFormat, mp3Setting, false);
mFileChannel = FileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE_NEW);
byte[] tag = getPaddedTag(AudioMetadataUtils.getMP3ID3(initialMetadata), RESERVED_TAG_SIZE);
if(tag == null)
{
//Initial tag is too large to pad - reserve an empty tag and rely on the rewrite at close
tag = getPaddedTag(AudioMetadataUtils.getMP3ID3(Map.of()), RESERVED_TAG_SIZE);
}
writeFully(ByteBuffer.wrap(tag));
}
@Override
public void write(List<float[]> audioBuffers) throws IOException
{
List<float[]> buffers = mNormalize ? normalize(audioBuffers) : audioBuffers;
writeFrames(mConverter.encodeStream(buffers));
}
/**
* Applies the peak-tracking normalization gain to copies of the buffers.
*/
List<float[]> normalize(List<float[]> audioBuffers)
{
List<float[]> normalized = new ArrayList<>(audioBuffers.size());
for(float[] audioBuffer: audioBuffers)
{
for(float sample: audioBuffer)
{
float magnitude = Math.abs(sample);
if(magnitude > mPeak && !Float.isNaN(magnitude))
{
mPeak = magnitude;
}
}
float gain = NORMALIZE_TARGET / mPeak;
float[] copy = Arrays.copyOf(audioBuffer, audioBuffer.length);
for(int x = 0; x < copy.length; x++)
{
copy[x] *= gain;
}
normalized.add(copy);
}
return normalized;
}
private void writeFrames(List<byte[]> frames) throws IOException
{
for(byte[] frame: frames)
{
writeFully(ByteBuffer.wrap(frame));
}
}
private void writeFully(ByteBuffer buffer) throws IOException
{
while(buffer.hasRemaining())
{
mFileChannel.write(buffer);
}
}
@Override
public void close(Map<AudioMetadata,String> metadata) throws IOException
{
try
{
writeFrames(mConverter.finishStream());
byte[] tag = getPaddedTag(AudioMetadataUtils.getMP3ID3(metadata), RESERVED_TAG_SIZE);
if(tag != null)
{
mFileChannel.write(ByteBuffer.wrap(tag), 0);
mFileChannel.force(true);
mFileChannel.close();
}
else
{
mFileChannel.force(true);
mFileChannel.close();
rewriteWithTag(AudioMetadataUtils.getMP3ID3(metadata));
}
}
finally
{
if(mFileChannel.isOpen())
{
mFileChannel.close();
}
}
}
/**
* Rewrites the file with the (unpadded) tag replacing the reserved tag space.
*/
private void rewriteWithTag(byte[] tag) throws IOException
{
Path temp = mPath.resolveSibling(mPath.getFileName() + ".tmp");
try(FileChannel source = FileChannel.open(mPath, StandardOpenOption.READ);
FileChannel target = FileChannel.open(temp, StandardOpenOption.WRITE, StandardOpenOption.CREATE,
StandardOpenOption.TRUNCATE_EXISTING))
{
ByteBuffer buffer = ByteBuffer.wrap(tag);
while(buffer.hasRemaining())
{
target.write(buffer);
}
long position = RESERVED_TAG_SIZE;
long size = source.size();
while(position < size)
{
position += source.transferTo(position, size - position, target);
}
}
Files.move(temp, mPath, StandardCopyOption.REPLACE_EXISTING);
}
@Override
public void abort()
{
try
{
mFileChannel.close();
}
catch(IOException ioe)
{
LOGGER.warn("Error closing aborted recording [" + mPath + "] - " + ioe.getMessage());
}
}
@Override
public Path getPath()
{
return mPath;
}
/**
* Pads an ID3v2 tag with zero bytes to the requested total size and updates the tag size in the header. ID3v2
* readers treat the zero bytes after the last frame as padding.
* @param tag complete ID3v2 tag (header and frames, no footer)
* @param size total size for the padded tag
* @return padded tag, or null if the tag is larger than the requested size or isn't a valid ID3v2 tag.
*/
static byte[] getPaddedTag(byte[] tag, int size)
{
if(tag == null || tag.length < ID3_HEADER_SIZE || tag.length > size || tag[0] != 'I' || tag[1] != 'D' ||
tag[2] != '3' || (tag[5] & 0x10) != 0)
{
return null;
}
byte[] padded = Arrays.copyOf(tag, size);
int tagSize = size - ID3_HEADER_SIZE;
//Synchsafe integer: 4 bytes of 7 bits each
padded[6] = (byte)((tagSize >> 21) & 0x7F);
padded[7] = (byte)((tagSize >> 14) & 0x7F);
padded[8] = (byte)((tagSize >> 7) & 0x7F);
padded[9] = (byte)(tagSize & 0x7F);
return padded;
}
}

View File

@@ -1,92 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.record.stream;
import io.github.dsheirer.audio.AudioFormats;
import io.github.dsheirer.record.wave.AudioMetadata;
import io.github.dsheirer.record.wave.AudioMetadataUtils;
import io.github.dsheirer.record.wave.WaveWriter;
import io.github.dsheirer.sample.ConversionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
/**
* Streaming WAVE recording. The RIFF and data chunk sizes are updated after each write, so the file is a valid WAVE
* file throughout the call. The LIST and ID3 metadata chunks are appended when the recording is closed.
*/
public class StreamingWaveWriter implements IStreamingAudioWriter
{
private static final Logger LOGGER = LoggerFactory.getLogger(StreamingWaveWriter.class);
private final WaveWriter mWaveWriter;
private final Path mPath;
/**
* Creates the recording file.
* @param path for the new file, which must not exist
*/
public StreamingWaveWriter(Path path) throws IOException
{
mPath = path;
mWaveWriter = new WaveWriter(AudioFormats.PCM_SIGNED_8000_HZ_16_BIT_MONO, path);
}
@Override
public void write(List<float[]> audioBuffers) throws IOException
{
for(float[] audioBuffer: audioBuffers)
{
mWaveWriter.writeData(ConversionUtils.convertToSigned16BitSamples(audioBuffer));
}
}
@Override
public void close(Map<AudioMetadata,String> metadata) throws IOException
{
ByteBuffer listChunk = AudioMetadataUtils.getLISTChunk(metadata);
byte[] id3Bytes = AudioMetadataUtils.getMP3ID3(metadata);
ByteBuffer id3Chunk = AudioMetadataUtils.getID3Chunk(id3Bytes);
mWaveWriter.writeMetadata(listChunk, id3Chunk);
mWaveWriter.close();
}
@Override
public void abort()
{
try
{
mWaveWriter.close();
}
catch(IOException ioe)
{
LOGGER.warn("Error closing aborted recording [" + mPath + "] - " + ioe.getMessage());
}
}
@Override
public Path getPath()
{
return mPath;
}
}

View File

@@ -33,7 +33,6 @@
-audio-text-dim: #5f6b78; -audio-text-dim: #5f6b78;
-audio-live: #3ddc84; -audio-live: #3ddc84;
-audio-muted: #ff5c5c; -audio-muted: #ff5c5c;
-audio-hold: #f0b429;
-audio-accent: #3ddc84; -audio-accent: #3ddc84;
-fx-background-color: -audio-display; -fx-background-color: -audio-display;
@@ -98,29 +97,6 @@
-fx-fill: -audio-muted; -fx-fill: -audio-muted;
} }
.audio-view .audio-hold-button:selected
{
-fx-background-color: derive(-audio-hold, -60%);
-fx-border-color: -audio-hold;
}
.audio-view .audio-hold-button:selected .audio-button-icon
{
-fx-fill: -audio-hold;
}
.audio-view .audio-hold-label
{
-fx-text-fill: -audio-hold;
-fx-font-size: 0.8em;
-fx-font-weight: bold;
}
.audio-view .audio-hold-label .text
{
-fx-fill: -audio-hold;
}
.audio-view .audio-master-mute .audio-view .audio-master-mute
{ {
-fx-padding: 6 10 6 10; -fx-padding: 6 10 6 10;
@@ -164,13 +140,6 @@
-fx-border-color: -audio-accent; -fx-border-color: -audio-accent;
} }
/* A channel that holds a talkgroup keeps the hold color border, playing or not */
.audio-view .audio-channel:held,
.audio-view .audio-channel:held:active
{
-fx-border-color: -audio-hold;
}
.audio-view .audio-accent .audio-view .audio-accent
{ {
-fx-background-color: transparent; -fx-background-color: transparent;
@@ -226,29 +195,6 @@
-fx-fill: -audio-text-secondary; -fx-fill: -audio-text-secondary;
} }
/* Channel tag colors match the Playing column of the Calls tab: left (and mono) blue, right orange */
.audio-view .audio-channel-tag-left
{
-fx-background-color: #4a90d9;
}
.audio-view .audio-channel-tag-right
{
-fx-background-color: #e8912d;
}
.audio-view .audio-channel-tag-left,
.audio-view .audio-channel-tag-right
{
-fx-text-fill: white;
}
.audio-view .audio-channel-tag-left .text,
.audio-view .audio-channel-tag-right .text
{
-fx-fill: white;
}
.audio-view .audio-status .audio-view .audio-status
{ {
-fx-text-fill: -audio-text-dim; -fx-text-fill: -audio-text-dim;

View File

@@ -34,9 +34,4 @@
<!-- Apache Mina TCP/HTTP library --> <!-- Apache Mina TCP/HTTP library -->
<logger name="org.apache.mina" level="INFO" /> <logger name="org.apache.mina" level="INFO" />
<!-- Call database: HikariCP connection pool (logs pool housekeeping every 30 seconds at DEBUG) and the MariaDB
driver, which logs through SLF4J -->
<logger name="com.zaxxer.hikari" level="INFO" />
<logger name="org.mariadb.jdbc" level="INFO" />
</configuration> </configuration>

View File

@@ -45,66 +45,3 @@
{ {
-fx-fill: -fx-accent; -fx-fill: -fx-accent;
} }
/* Calls tab: a TO/FROM search field shows a selected alias (rather than typed text) in bold */
.calls-view .calls-alias-search:alias-selected
{
-fx-font-weight: bold;
}
/* Calls tab: calls that are playing on an audio channel. Left (and mono) is blue and right is orange, matching the
channel tags in the audio panel. The row tint is a translucent overlay so it works with every theme and with the
row selection color. Chip text is set on the label and its .text node for the dark theme. */
.calls-view
{
-calls-playing-left: #4a90d9;
-calls-playing-right: #e8912d;
}
/* The channel color edge is a background layer, not a border: a border takes layout space and shifts the row's
cells out of alignment with the other rows. */
.calls-view .table-row-cell:playing-left,
.calls-view .table-row-cell:playing-mono
{
-fx-background-color: -fx-table-cell-border-color, -calls-playing-left, -fx-background,
rgba(74, 144, 217, 0.20);
-fx-background-insets: 0, 0 0 1 0, 0 0 1 4, 0 0 1 4;
}
.calls-view .table-row-cell:playing-right
{
-fx-background-color: -fx-table-cell-border-color, -calls-playing-right, -fx-background,
rgba(232, 145, 45, 0.20);
-fx-background-insets: 0, 0 0 1 0, 0 0 1 4, 0 0 1 4;
}
.calls-view .calls-playing-chip
{
-fx-background-radius: 4;
-fx-padding: 0 6 0 5;
-fx-graphic-text-gap: 4;
-fx-font-size: 0.8em;
-fx-font-weight: bold;
-fx-text-fill: white;
}
.calls-view .calls-playing-chip .text
{
-fx-fill: white;
}
.calls-view .calls-playing-chip .calls-playing-icon
{
-fx-fill: white;
}
.calls-view .calls-playing-left,
.calls-view .calls-playing-mono
{
-fx-background-color: -calls-playing-left;
}
.calls-view .calls-playing-right
{
-fx-background-color: -calls-playing-right;
}

View File

@@ -82,6 +82,7 @@ public class TalkerAliasAutoAdderTest
assertEquals(TalkerAliasAutoAdder.ALIAS_GROUP, alias.getGroup()); assertEquals(TalkerAliasAutoAdder.ALIAS_GROUP, alias.getGroup());
assertTrue(alias.getAliasIdentifiers().get(0) instanceof Radio radio && radio.getValue() == 1234 && assertTrue(alias.getAliasIdentifiers().get(0) instanceof Radio radio && radio.getValue() == 1234 &&
radio.getProtocol() == Protocol.APCO25); radio.getProtocol() == Protocol.APCO25);
assertEquals("Radio ID:1234 Protocol:APCO-25", alias.getAliasIdentifiers().get(0).valueProperty().get());
decode(RADIO, "ENGINE 12"); decode(RADIO, "ENGINE 12");
assertEquals(1, aliases().size(), "no duplicate alias"); assertEquals(1, aliases().size(), "no duplicate alias");
@@ -252,6 +253,8 @@ public class TalkerAliasAutoAdderTest
decode(roaming, "ROAMER"); decode(roaming, "ROAMER");
Alias alias = alias(roaming); Alias alias = alias(roaming);
assertTrue(alias.getAliasIdentifiers().get(0) instanceof P25FullyQualifiedRadio); assertTrue(alias.getAliasIdentifiers().get(0) instanceof P25FullyQualifiedRadio);
assertEquals("Fully Qualified Radio ID:781824.291.777 Protocol:APCO-25",
alias.getAliasIdentifiers().get(0).valueProperty().get());
assertNull(alias(RADIO), "local radio with the same value isn't aliased"); assertNull(alias(RADIO), "local radio with the same value isn't aliased");
} }

View File

@@ -1,151 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.audio.playback;
import io.github.dsheirer.alias.AliasList;
import io.github.dsheirer.audio.AudioSegment;
import io.github.dsheirer.preference.UserPreferences;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
/**
* The audio channel reports the call (audio segment) that it starts and stops playing, which the Calls tab uses to
* show which calls are playing on each channel.
*/
public class AudioChannelPlaybackListenerTest
{
private static final float[] AUDIO = new float[AudioChannel.SAMPLES_PER_INTERVAL];
private AudioChannel mChannel;
private final List<AudioSegment> mEvents = new ArrayList<>();
@BeforeEach
public void setup()
{
mChannel = new AudioChannel(new UserPreferences(), "LEFT");
mChannel.setPlaybackListener(() -> mEvents.add(mChannel.getCurrentAudioSegment()));
}
@AfterEach
public void teardown()
{
mChannel.dispose();
}
private static AudioSegment segment()
{
AudioSegment segment = new AudioSegment(new AliasList("test"), 0);
segment.incrementConsumerCount();
segment.addAudio(AUDIO);
return segment;
}
@Test
public void reportsStartAndStopOfEachCall()
{
AudioSegment first = segment();
AudioSegment second = segment();
assertNotEquals(first.getId(), second.getId(), "audio segment ids are unique");
mChannel.play(first);
mChannel.play(second);
mChannel.getAudio();
assertSame(first, mChannel.getCurrentAudioSegment());
assertEquals(List.of(first), mEvents, "first call started");
first.completeProperty().set(true);
second.completeProperty().set(true);
for(int x = 0; x < 10; x++)
{
mChannel.getAudio();
}
assertSame(first, mEvents.get(0));
assertNull(mEvents.get(1), "first call stopped");
assertSame(second, mEvents.get(2), "second call started");
assertNull(mEvents.get(3), "second call stopped");
assertNull(mChannel.getCurrentAudioSegment());
}
@Test
public void replayTakesOverChannelAndLiveCallsResumeAfter()
{
AudioSegment live = segment();
mChannel.play(live);
mChannel.getAudio();
assertSame(live, mChannel.getCurrentAudioSegment());
AudioSegment queued = segment();
mChannel.play(queued);
float[] samples = new float[AudioChannel.SAMPLES_PER_INTERVAL * 3];
java.util.Arrays.fill(samples, 0.25f);
ReplaySource replay = new ReplaySource(samples, 42, "Replay");
mChannel.startReplay(replay);
assertEquals(true, mChannel.isReplaying());
float[] audio = mChannel.getAudio();
assertEquals(0.25f, audio[0], 0.0001f, "replay audio replaces the live call");
assertNull(mChannel.getCurrentAudioSegment(), "live call dropped");
assertSame(replay, mChannel.getReplay());
replay.setPaused(true);
assertEquals(0.0f, mChannel.getAudio()[0], 0.0001f, "paused replay is silent");
replay.setPaused(false);
mChannel.getAudio();
mChannel.getAudio();
assertEquals(true, replay.isCompleted(), "replay played to the end");
//Next interval releases the replay and the queued live call plays
mChannel.getAudio();
assertNull(mChannel.getReplay());
assertSame(queued, mChannel.getCurrentAudioSegment(), "queued live call plays after the replay");
}
@Test
public void replayingChannelIsSkippedForLiveCalls()
{
AudioChannel right = new AudioChannel(new UserPreferences(), "RIGHT");
try
{
mChannel.startReplay(new ReplaySource(new float[8000], 7, "Replay"));
AudioSegment live = segment();
List<AudioSegment> waiting = new ArrayList<>(List.of(live));
AudioPlaybackManager.assignAudioSegments(waiting, List.of(mChannel, right));
assertNull(mChannel.peekQueuedAudioSegment(), "replaying channel isn't assigned live calls");
assertSame(live, right.peekQueuedAudioSegment());
}
finally
{
right.dispose();
}
}
}

View File

@@ -1,186 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.audio.playback;
import io.github.dsheirer.alias.AliasList;
import io.github.dsheirer.audio.AudioSegment;
import io.github.dsheirer.database.call.CallRecord;
import io.github.dsheirer.identifier.patch.PatchGroup;
import io.github.dsheirer.module.decode.dmr.identifier.DMRTalkgroup;
import io.github.dsheirer.module.decode.p25.identifier.patch.APCO25PatchGroup;
import io.github.dsheirer.module.decode.p25.identifier.talkgroup.APCO25Talkgroup;
import io.github.dsheirer.preference.UserPreferences;
import io.github.dsheirer.protocol.Protocol;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Talkgroup hold matching and hold-aware assignment of calls to audio channels.
*/
public class TalkgroupHoldTest
{
private static final float[] AUDIO = new float[AudioChannel.SAMPLES_PER_INTERVAL];
private AudioChannel mLeft;
private AudioChannel mRight;
@BeforeEach
public void setup()
{
UserPreferences userPreferences = new UserPreferences();
mLeft = new AudioChannel(userPreferences, "LEFT");
mRight = new AudioChannel(userPreferences, "RIGHT");
}
@AfterEach
public void teardown()
{
mLeft.dispose();
mRight.dispose();
}
private static AudioSegment call(int talkgroup)
{
AudioSegment segment = new AudioSegment(new AliasList("test"), 0);
segment.incrementConsumerCount();
segment.addIdentifier(APCO25Talkgroup.create(talkgroup));
segment.addAudio(AUDIO);
return segment;
}
private static TalkgroupHold hold(int talkgroup)
{
return new TalkgroupHold(Protocol.APCO25, talkgroup, String.valueOf(talkgroup));
}
@Test
public void matchesTalkgroupAndProtocol()
{
TalkgroupHold hold = hold(100);
assertTrue(hold.matches(call(100)));
assertFalse(hold.matches(call(101)));
AudioSegment dmr = new AudioSegment(new AliasList("test"), 0);
dmr.addIdentifier(DMRTalkgroup.create(100));
assertFalse(hold.matches(dmr), "same value on a different protocol");
TalkgroupHold phase2 = new TalkgroupHold(Protocol.APCO25_PHASE2, 100, "100");
assertTrue(phase2.matches(call(100)), "P25 phase 1 and phase 2 share talkgroups");
}
@Test
public void matchesPatchGroupAndMembers()
{
PatchGroup patchGroup = new PatchGroup(APCO25Talkgroup.create(500));
patchGroup.addPatchedTalkgroup(APCO25Talkgroup.create(100));
AudioSegment segment = new AudioSegment(new AliasList("test"), 0);
segment.addIdentifier(APCO25PatchGroup.create(patchGroup));
assertTrue(hold(500).matches(segment), "patch group talkgroup");
assertTrue(hold(100).matches(segment), "patched member talkgroup");
assertFalse(hold(101).matches(segment));
}
@Test
public void createFromCallRecord()
{
CallRecord call = new CallRecord();
call.setProtocol(Protocol.APCO25.name());
call.setToId("100");
call.setToValue(100L);
call.setToForm(CallRecord.FORM_TALKGROUP);
TalkgroupHold hold = TalkgroupHold.from(call, "Fire");
assertNotNull(hold);
assertEquals("100 Fire", hold.label());
assertTrue(hold.matches(call(100)));
call.setToForm(CallRecord.FORM_RADIO);
assertNull(TalkgroupHold.from(call, null), "private call to a radio isn't a talkgroup");
}
@Test
public void heldTalkgroupIsSteeredToHoldingChannel()
{
mRight.setHold(hold(100));
AudioSegment held = call(100);
List<AudioSegment> waiting = new ArrayList<>(List.of(held));
AudioPlaybackManager.assignAudioSegments(waiting, List.of(mLeft, mRight));
assertTrue(waiting.isEmpty());
assertSame(held, mRight.peekQueuedAudioSegment(), "held call goes to the holding channel");
assertNull(mLeft.peekQueuedAudioSegment(), "even though the left channel is free");
}
@Test
public void otherCallsAreKeptOffHoldingChannel()
{
mLeft.setHold(hold(100));
AudioSegment first = call(200);
AudioSegment second = call(300);
List<AudioSegment> waiting = new ArrayList<>(List.of(first, second));
AudioPlaybackManager.assignAudioSegments(waiting, List.of(mLeft, mRight));
assertNull(mLeft.peekQueuedAudioSegment(), "held channel stays free for the held talkgroup");
assertSame(first, mRight.peekQueuedAudioSegment());
assertEquals(List.of(second), waiting, "second call waits for the unheld channel");
}
@Test
public void heldChannelPlaysDoNotMonitorCallOfHeldTalkgroupOnly()
{
mLeft.setHold(hold(100));
AudioSegment held = call(100);
held.monitorPriorityProperty().set(-1);
assertTrue(held.isDoNotMonitor());
AudioSegment other = call(200);
mLeft.play(other);
mLeft.play(held);
//The non-matching call is thrown away and the held do-not-monitor call plays
assertNotNull(mLeft.getAudio());
assertTrue(mLeft.isPlayingHeldTalkgroup());
}
@Test
public void noHoldKeepsExistingAssignment()
{
AudioSegment first = call(200);
AudioSegment second = call(300);
List<AudioSegment> waiting = new ArrayList<>(List.of(first, second));
AudioPlaybackManager.assignAudioSegments(waiting, List.of(mLeft, mRight));
assertSame(first, mLeft.peekQueuedAudioSegment());
assertSame(second, mRight.peekQueuedAudioSegment());
assertTrue(waiting.isEmpty());
}
}

View File

@@ -1,49 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.call;
import io.github.dsheirer.database.call.PatchedTalkgroup;
import io.github.dsheirer.identifier.patch.PatchGroup;
import io.github.dsheirer.module.decode.p25.identifier.patch.APCO25PatchGroup;
import io.github.dsheirer.module.decode.p25.identifier.talkgroup.APCO25FullyQualifiedTalkgroupIdentifier;
import io.github.dsheirer.module.decode.p25.identifier.talkgroup.APCO25Talkgroup;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* The call manager captures the talkgroups patched into a patch group call.
*/
public class CallManagerPatchTest
{
@Test
public void capturesPatchedTalkgroups()
{
PatchGroup patchGroup = new PatchGroup(APCO25Talkgroup.create(500));
patchGroup.addPatchedTalkgroup(APCO25Talkgroup.create(1001));
patchGroup.addPatchedTalkgroup(APCO25FullyQualifiedTalkgroupIdentifier.createTo(1002, 781824, 1, 1002));
List<PatchedTalkgroup> patched = CallManager.getPatchedTalkgroups(APCO25PatchGroup.create(patchGroup));
assertEquals(List.of(new PatchedTalkgroup(1001, null), new PatchedTalkgroup(1002, "781824.1.1002")), patched);
assertEquals(List.of(), CallManager.getPatchedTalkgroups(APCO25Talkgroup.create(1001)), "not a patch group");
}
}

View File

@@ -1,453 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database;
import io.github.dsheirer.alias.Alias;
import io.github.dsheirer.alias.id.radio.RadioRange;
import io.github.dsheirer.alias.id.talkgroup.P25FullyQualifiedTalkgroup;
import io.github.dsheirer.alias.id.talkgroup.Talkgroup;
import io.github.dsheirer.alias.id.talkgroup.TalkgroupRange;
import io.github.dsheirer.database.call.CallRecord;
import io.github.dsheirer.database.call.ICallRepository;
import io.github.dsheirer.database.call.CallSearchCriteria;
import io.github.dsheirer.database.call.CallState;
import io.github.dsheirer.database.call.CallType;
import io.github.dsheirer.database.call.CallRepository;
import io.github.dsheirer.database.call.IdentifierFilter;
import io.github.dsheirer.database.call.PatchedTalkgroup;
import io.github.dsheirer.database.call.RecordingState;
import io.github.dsheirer.protocol.Protocol;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.Path;
import java.sql.Connection;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Schema installation, call insert/update/search and age-off queries against the built-in H2 database.
*
* The same checks run against network MariaDB and PostgreSQL servers when these environment variables are set to
* host:port:user:password (and, for PostgreSQL, host:port:user:password:database):
* SDRTRUNK_TEST_MARIADB, SDRTRUNK_TEST_POSTGRES
* The tests use (and drop) the schema 'sdrtrunk_unit_test'.
*/
public class CallDatabaseTest
{
private static final String TEST_SCHEMA = "sdrtrunk_unit_test";
@TempDir
Path mTempDir;
@Test
public void h2()
throws Exception
{
exercise(new DatabaseConfiguration(DatabaseType.H2, "", 0, "", TEST_SCHEMA, "", ""));
}
@Test
public void mariadb()
throws Exception
{
DatabaseConfiguration configuration = fromEnvironment("SDRTRUNK_TEST_MARIADB", DatabaseType.MARIADB);
Assumptions.assumeTrue(configuration != null, "SDRTRUNK_TEST_MARIADB not set");
exercise(configuration);
}
@Test
public void postgres()
throws Exception
{
DatabaseConfiguration configuration = fromEnvironment("SDRTRUNK_TEST_POSTGRES", DatabaseType.POSTGRESQL);
Assumptions.assumeTrue(configuration != null, "SDRTRUNK_TEST_POSTGRES not set");
exercise(configuration);
}
private static DatabaseConfiguration fromEnvironment(String variable, DatabaseType type)
{
String value = System.getenv(variable);
if(value == null || value.isBlank())
{
return null;
}
String[] parts = value.split(":");
String database = parts.length > 4 ? parts[4] : "postgres";
return new DatabaseConfiguration(type, parts[0], Integer.parseInt(parts[1]), database, TEST_SCHEMA, parts[2],
parts[3]);
}
private static CallRecord call(long start, String to, long toValue, String talkerAlias, String from,
long fromValue, String path, long size)
{
CallRecord call = new CallRecord();
call.setStartTime(start);
call.setProtocol(Protocol.APCO25.name());
call.setSystem("Metro System");
call.setSite("Site 1");
call.setChannel("Control");
call.setFrequency(851_012_500);
call.setToId(to);
call.setToValue(toValue);
call.setToForm(CallRecord.FORM_TALKGROUP);
call.setFromId(from);
call.setFromValue(fromValue);
call.setFromForm(CallRecord.FORM_RADIO);
call.setAliasList("Metro");
call.setTalkerAlias(talkerAlias);
call.setRecordFormat("MP3");
call.setFilePath(path);
call.setFileSize(size);
call.setRecordingState(path != null ? RecordingState.RECORDING : RecordingState.NONE);
return call;
}
private void exercise(DatabaseConfiguration configuration) throws Exception
{
try(CallDatabase database = new CallDatabase(configuration, mTempDir))
{
try(Connection connection = database.getConnection();
java.sql.Statement statement = connection.createStatement())
{
statement.execute(configuration.type().getDialect().getDropSchemaStatement(TEST_SCHEMA));
}
assertEquals(SchemaStatus.MISSING, database.getSchemaStatus());
database.install();
assertEquals(SchemaStatus.SDRTRUNK, database.getSchemaStatus());
//Installing again is a no-op
database.install();
ICallRepository repository = database.getCallRepository();
try(Connection connection = database.getConnection())
{
CallRecord active = call(1000, "1234", 1234, "Fire Dispatch", "5551212", 5551212, "/rec/a.mp3", 0);
long id = repository.insert(connection, active);
assertTrue(id > 0);
active.setEndTime(4000);
active.setCallState(CallState.COMPLETE);
active.setRecordingState(RecordingState.RECORDED);
active.setFileSize(10_000);
assertTrue(repository.update(connection, active));
CallRecord second = call(5000, "2000", 2000, "Police_Tac 100%", "777", 777, "/rec/b.mp3", 0);
second.setRecordingState(RecordingState.RECORDED);
second.setFileSize(20_000);
second.setCallState(CallState.COMPLETE);
second.setEndTime(6000);
repository.insert(connection, second);
CallRecord unrecorded = call(7000, "2000", 2000, "Police_Tac 100%", "778", 778, null, 0);
long unrecordedId = repository.insert(connection, unrecorded);
assertNotEquals(id, unrecordedId);
assertEquals(3, repository.count(connection));
List<CallRecord> all = repository.search(connection, CallSearchCriteria.all(), 0, 100);
assertEquals(3, all.size());
assertEquals(7000, all.get(0).getStartTime(), "newest first");
CallRecord loaded = all.get(2);
assertEquals(3000, loaded.getDuration());
assertEquals("Fire Dispatch", loaded.getTalkerAlias());
assertEquals("Metro", loaded.getAliasList());
assertEquals(1234L, loaded.getToValue());
assertTrue(loaded.isToTalkgroup());
assertTrue(loaded.isFromRadio());
assertEquals(CallState.COMPLETE, loaded.getCallState());
assertEquals(Protocol.APCO25, loaded.getProtocolValue());
assertEquals(2, search(repository, connection, "2000", null, null));
assertEquals(1, search(repository, connection, "123", null, null), "partial match");
assertEquals(1, search(repository, connection, null, "5551212", null));
assertEquals(1, search(repository, connection, null, null, "fire dis"), "case insensitive");
assertEquals(2, search(repository, connection, null, null, "tac 100%"), "literal percent");
assertEquals(0, search(repository, connection, null, null, "police%tac"), "escaped wildcard");
assertEquals(0, search(repository, connection, null, null, "police_tac_"), "escaped underscore");
assertEquals(2, repository.count(connection, new CallSearchCriteria(null, null, null,
Protocol.APCO25, "metro", 4000, 8000)));
for(CallRecord call: all)
{
CallSearchCriteria criteria = new CallSearchCriteria(IdentifierFilter.text("2000"), null, "tac",
null, null, 0, 0);
assertEquals(call.getToValue() == 2000, criteria.matches(call), "in-memory matches agrees");
}
//Roaming (fully qualified) talkgroup call: local value 2000, fully qualified 0xBEE00.1.2000
CallRecord roaming = call(8000, "2000", 2000, null, "779", 779, null, 0);
roaming.setToFullyQualified("781824.1.2000");
repository.insert(connection, roaming);
//Alias searches: the alias identifiers are translated to value, range and fully qualified filters
Alias talkgroupAlias = new Alias("Police Tac");
talkgroupAlias.setAliasListName("Metro");
talkgroupAlias.addAliasID(new Talkgroup(Protocol.APCO25, 2000));
talkgroupAlias.addAliasID(new TalkgroupRange(Protocol.APCO25, 1200, 1300));
assertEquals(3, aliasSearch(repository, connection, IdentifierFilter.talkgroupAlias(talkgroupAlias),
null), "talkgroup value and range, not the fully qualified call");
Alias roamingAlias = new Alias("Roaming Tac");
roamingAlias.setAliasListName("metro");
roamingAlias.addAliasID(new P25FullyQualifiedTalkgroup(781824, 1, 2000));
assertEquals(1, aliasSearch(repository, connection, IdentifierFilter.talkgroupAlias(roamingAlias),
null), "fully qualified talkgroup only, alias list name case-insensitive");
Alias otherList = new Alias("Police Tac");
otherList.setAliasListName("County");
otherList.addAliasID(new Talkgroup(Protocol.APCO25, 2000));
assertEquals(0, aliasSearch(repository, connection, IdentifierFilter.talkgroupAlias(otherList), null),
"alias from a different alias list");
Alias dmrAlias = new Alias("DMR 2000");
dmrAlias.setAliasListName("Metro");
dmrAlias.addAliasID(new Talkgroup(Protocol.DMR, 2000));
assertEquals(0, aliasSearch(repository, connection, IdentifierFilter.talkgroupAlias(dmrAlias), null),
"different protocol");
Alias radioAlias = new Alias("Engine 7");
radioAlias.setAliasListName("Metro");
radioAlias.addAliasID(new RadioRange(Protocol.APCO25, 776, 778));
assertEquals(2, aliasSearch(repository, connection, null, IdentifierFilter.radioAlias(radioAlias)),
"radio range");
assertEquals(2, aliasSearch(repository, connection, IdentifierFilter.talkgroupAlias(talkgroupAlias),
IdentifierFilter.radioAlias(radioAlias)), "talkgroup and radio alias combined");
List<CallRecord> withRoaming = repository.search(connection, CallSearchCriteria.all(), 0, 100);
for(IdentifierFilter filter: List.of(IdentifierFilter.talkgroupAlias(talkgroupAlias),
IdentifierFilter.talkgroupAlias(roamingAlias), IdentifierFilter.talkgroupAlias(otherList),
IdentifierFilter.talkgroupAlias(dmrAlias)))
{
CallSearchCriteria criteria = new CallSearchCriteria(filter, null, null, null, null, 0, 0);
long inMemory = withRoaming.stream().filter(criteria::matches).count();
assertEquals(repository.count(connection, criteria), inMemory, "in-memory alias match " + filter);
}
repository.delete(connection, List.of(roaming.getId()));
//Retention rule: duplicates and Do Not Monitor calls without an alias record option
CallRecord duplicate = call(100, "3000", 3000, null, "1", 1, null, 0);
duplicate.setDuplicate(true);
duplicate.setCallState(CallState.COMPLETE);
CallRecord doNotMonitor = call(200, "3001", 3001, null, "2", 2, null, 0);
doNotMonitor.setPriority(-1);
doNotMonitor.setCallState(CallState.COMPLETE);
CallRecord recordedDoNotMonitor = call(300, "3002", 3002, null, "3", 3, null, 0);
recordedDoNotMonitor.setPriority(-1);
recordedDoNotMonitor.setAliasRecord(true);
recordedDoNotMonitor.setCallState(CallState.COMPLETE);
CallRecord activeDuplicate = call(400, "3003", 3003, null, "4", 4, null, 0);
activeDuplicate.setDuplicate(true);
CallRecord newDuplicate = call(900_000, "3004", 3004, null, "5", 5, null, 0);
newDuplicate.setDuplicate(true);
newDuplicate.setCallState(CallState.COMPLETE);
List<CallRecord> retention = List.of(duplicate, doNotMonitor, recordedDoNotMonitor, activeDuplicate,
newDuplicate);
for(CallRecord call: retention)
{
repository.insert(connection, call);
}
List<CallRecord> expired = repository.getDuplicateAndDoNotMonitorCalls(connection, 1000, 100);
assertEquals(List.of(100L, 200L), expired.stream().map(CallRecord::getStartTime).toList(),
"completed duplicate and Do Not Monitor calls before the cutoff, oldest first");
assertTrue(repository.search(connection, new CallSearchCriteria(IdentifierFilter.text("3002"), null,
null, null, null, 0, 0), 0, 1).getFirst().isAliasRecord());
repository.delete(connection, retention.stream().map(CallRecord::getId).toList());
//Patch group call: patch group 500 with patched talkgroups 2000 and 4000 (fully qualified 4001)
CallRecord patch = call(9500, "P:500", 500, null, "9", 9, null, 0);
patch.setToForm(CallRecord.FORM_PATCH_GROUP);
patch.setPatchedTalkgroups(List.of(new PatchedTalkgroup(4000, null),
new PatchedTalkgroup(4001, "781824.1.4001")));
repository.insert(connection, patch);
patch.setPatchedTalkgroups(List.of(new PatchedTalkgroup(2000, null), new PatchedTalkgroup(4000, null),
new PatchedTalkgroup(4001, "781824.1.4001")));
repository.update(connection, patch);
CallRecord loadedPatch = repository.search(connection, new CallSearchCriteria(
IdentifierFilter.text("4000"), null, null, null, null, 0, 0), 0, 10).getFirst();
assertEquals(patch.getId(), loadedPatch.getId(), "typed patched talkgroup finds the patch call");
assertEquals(3, loadedPatch.getPatchedTalkgroups().size(), "patched talkgroups replaced on update");
assertEquals(1, search(repository, connection, "500", null, null), "patch group value still matches");
assertEquals(3, search(repository, connection, "2000", null, null),
"talkgroup 2000 calls plus the patch call that included it");
Alias patchedAlias = new Alias("Tac 4000");
patchedAlias.setAliasListName("Metro");
patchedAlias.addAliasID(new TalkgroupRange(Protocol.APCO25, 3990, 4005));
assertEquals(1, aliasSearch(repository, connection, IdentifierFilter.talkgroupAlias(patchedAlias),
null), "alias range matches a patched talkgroup");
Alias patchedFq = new Alias("Roaming 4001");
patchedFq.setAliasListName("Metro");
patchedFq.addAliasID(new P25FullyQualifiedTalkgroup(781824, 1, 4001));
assertEquals(1, aliasSearch(repository, connection, IdentifierFilter.talkgroupAlias(patchedFq),
null), "fully qualified patched talkgroup");
List<CallRecord> withPatch = repository.search(connection, CallSearchCriteria.all(), 0, 100);
for(IdentifierFilter filter: List.of(IdentifierFilter.text("4000"), IdentifierFilter.text("2000"),
IdentifierFilter.talkgroupAlias(patchedAlias), IdentifierFilter.talkgroupAlias(patchedFq)))
{
CallSearchCriteria criteria = new CallSearchCriteria(filter, null, null, null, null, 0, 0);
assertEquals(repository.count(connection, criteria),
withPatch.stream().filter(criteria::matches).count(), "in-memory patched match " + filter);
}
assertEquals(3, repository.readPage(connection, patch.getId() - 1, 1).getFirst()
.getPatchedTalkgroups().size(), "transfer page reads patched talkgroups");
//Call type filter: one call of each type alongside the group and patch calls
CallRecord privateCall = call(9600, "777", 777, null, "778", 778, null, 0);
privateCall.setToForm(CallRecord.FORM_RADIO);
CallRecord phoneTo = call(9601, "5551234", 0, null, "779", 779, null, 0);
phoneTo.setToForm("TELEPHONE_NUMBER");
phoneTo.setToValue(null);
CallRecord phoneFrom = call(9602, "780", 780, null, "5559876", 0, null, 0);
phoneFrom.setToForm(CallRecord.FORM_RADIO);
phoneFrom.setFromForm("TELEPHONE_NUMBER");
CallRecord analog = call(9603, null, 0, null, null, 0, null, 0);
analog.setToForm(null);
analog.setToValue(null);
analog.setFromForm(null);
List<CallRecord> typed = List.of(privateCall, phoneTo, phoneFrom, analog);
for(CallRecord call: typed)
{
repository.insert(connection, call);
}
List<CallRecord> everything = repository.search(connection, CallSearchCriteria.all(), 0, 1000);
for(CallType type: CallType.values())
{
CallSearchCriteria criteria = new CallSearchCriteria(null, null, null, null, type, null, 0, 0);
long expected = everything.stream().filter(c -> c.getCallType() == type).count();
assertEquals(expected, repository.count(connection, criteria), "SQL type filter " + type);
assertEquals(expected, everything.stream().filter(criteria::matches).count(),
"in-memory type filter " + type);
assertTrue(expected > 0, "test data has a " + type + " call");
}
assertEquals(2, repository.count(connection, new CallSearchCriteria(null, null, null, null,
CallType.TELEPHONE, null, 0, 0)), "telephone calls in both directions");
repository.delete(connection, typed.stream().map(CallRecord::getId).toList());
repository.delete(connection, List.of(patch.getId()));
try(java.sql.Statement statement = connection.createStatement();
java.sql.ResultSet rs = statement.executeQuery("SELECT COUNT(*) FROM " + TEST_SCHEMA + "." +
CallRepository.PATCHED_TABLE))
{
rs.next();
assertEquals(0, rs.getLong(1), "patched talkgroups deleted with the call");
}
assertEquals(30_000, repository.getRecordedFileSize(connection));
List<CallRecord> recorded = repository.getRecordedCalls(connection, 0, 10);
assertEquals(2, recorded.size());
assertEquals(1000, recorded.get(0).getStartTime(), "oldest first");
assertEquals(1, repository.getRecordedCalls(connection, 4000, 10).size());
repository.markRecordingsDeleted(connection, List.of(id));
assertEquals(20_000, repository.getRecordedFileSize(connection));
CallRecord deleted = repository.search(connection, CallSearchCriteria.all(), 2, 1).getFirst();
assertEquals(RecordingState.DELETED, deleted.getRecordingState());
assertEquals(null, deleted.getFilePath());
assertEquals(3, repository.getTransferKeys(connection).size());
repository.delete(connection, List.of(unrecordedId));
assertEquals(2, repository.count(connection));
CallRecord interrupted = call(9000, "3", 3, null, "4", 4, "/rec/c.mp3", 0);
repository.insert(connection, interrupted);
assertEquals(1, repository.markInterrupted(connection));
CallRecord reloaded = repository.search(connection, CallSearchCriteria.all(), 0, 1).getFirst();
assertEquals(CallState.INTERRUPTED, reloaded.getCallState());
assertEquals(RecordingState.RECORDED, reloaded.getRecordingState());
List<CallRecord> transfer = repository.readPage(connection, 0, 100);
assertEquals(3, transfer.size());
repository.insertBatch(connection, transfer);
assertEquals(6, repository.count(connection));
}
//Upgrade from schema version 1: the patched talkgroups table is added
try(Connection connection = database.getConnection();
java.sql.Statement statement = connection.createStatement())
{
statement.execute("DROP TABLE " + TEST_SCHEMA + "." + CallRepository.PATCHED_TABLE);
statement.executeUpdate("UPDATE " + TEST_SCHEMA + "." + CallDatabase.SCHEMA_INFO_TABLE +
" SET version = 1");
}
database.install();
try(Connection connection = database.getConnection();
java.sql.Statement statement = connection.createStatement();
java.sql.ResultSet rs = statement.executeQuery("SELECT version FROM " + TEST_SCHEMA + "." +
CallDatabase.SCHEMA_INFO_TABLE))
{
rs.next();
assertEquals(CallDatabase.SCHEMA_VERSION, rs.getInt(1), "upgraded to the current version");
statement.executeQuery("SELECT COUNT(*) FROM " + TEST_SCHEMA + "." + CallRepository.PATCHED_TABLE)
.close();
}
String suggested = database.suggestSchemaName();
assertEquals(TEST_SCHEMA + "_2", suggested);
assertFalse(database.schemaExists(suggested));
database.clear();
assertEquals(SchemaStatus.SDRTRUNK, database.getSchemaStatus());
assertEquals(0, database.getCallCount());
try(Connection connection = database.getConnection();
java.sql.Statement statement = connection.createStatement())
{
statement.execute(configuration.type().getDialect().getDropSchemaStatement(TEST_SCHEMA));
}
}
}
private static long search(ICallRepository repository, Connection connection, String talkgroup, String radio,
String talkerAlias) throws Exception
{
return repository.count(connection, new CallSearchCriteria(IdentifierFilter.text(talkgroup),
IdentifierFilter.text(radio), talkerAlias, null, null, 0, 0));
}
private static long aliasSearch(ICallRepository repository, Connection connection, IdentifierFilter to,
IdentifierFilter from) throws Exception
{
return repository.count(connection, new CallSearchCriteria(to, from, null, null, null, 0, 0));
}
}

View File

@@ -1,45 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.database.call;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Call type derived from the stored TO and FROM identifier forms
*/
public class CallTypeTest
{
@Test
public void callTypes()
{
assertEquals(CallType.GROUP, CallType.from("TALKGROUP", "RADIO"));
assertEquals(CallType.PATCH, CallType.from("PATCH_GROUP", "RADIO"));
assertEquals(CallType.PRIVATE, CallType.from("RADIO", "RADIO"));
assertEquals(CallType.TELEPHONE, CallType.from("TELEPHONE_NUMBER", "RADIO"), "radio to telephone");
assertEquals(CallType.TELEPHONE, CallType.from("RADIO", "TELEPHONE_NUMBER"), "telephone to radio");
assertEquals(CallType.UNKNOWN, CallType.from(null, null), "no TO identifier");
CallRecord call = new CallRecord();
call.setToForm(CallRecord.FORM_RADIO);
call.setFromForm(CallRecord.FORM_RADIO);
assertEquals("Private", call.getCallType().toString());
}
}

View File

@@ -1,40 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.gui.calls;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Calls tab page size preference choices
*/
public class CallsViewPageSizeTest
{
@Test
public void pageSizeChoices()
{
assertEquals(List.of(50, 100, 250, 500), CallsView.PAGE_SIZES);
assertEquals(500, CallsView.DEFAULT_PAGE_SIZE);
assertEquals(250, CallsView.getStoredPageSize(250));
assertEquals(500, CallsView.getStoredPageSize(75), "invalid stored value uses the default");
}
}

View File

@@ -1,121 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.record;
import io.github.dsheirer.audio.convert.InputAudioFormat;
import io.github.dsheirer.audio.convert.MP3Setting;
import io.github.dsheirer.record.stream.StreamingMP3Writer;
import io.github.dsheirer.record.stream.StreamingWaveWriter;
import io.github.dsheirer.record.wave.AudioMetadata;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Recordings written by the streaming writers read back as 8 kHz audio for replay.
*/
public class RecordingReaderTest
{
@TempDir
Path mTempDir;
private static List<float[]> tone(int buffers)
{
List<float[]> audio = new ArrayList<>();
int sample = 0;
for(int x = 0; x < buffers; x++)
{
float[] buffer = new float[160];
for(int y = 0; y < 160; y++)
{
buffer[y] = 0.5f * (float)Math.sin(2.0 * Math.PI * 1000.0 * sample++ / 8000.0);
}
audio.add(buffer);
}
return audio;
}
/**
* RMS of the middle of the samples and the count of zero crossings, to verify level and frequency.
*/
private static void assertTone(float[] samples, int expectedSamples, String label)
{
assertEquals(expectedSamples, samples.length, expectedSamples * 0.08, label + " length");
int start = samples.length / 4;
int end = samples.length * 3 / 4;
double sum = 0;
int crossings = 0;
for(int x = start; x < end; x++)
{
sum += samples[x] * samples[x];
if(x > start && (samples[x - 1] < 0) != (samples[x] < 0))
{
crossings++;
}
}
double rms = Math.sqrt(sum / (end - start));
double frequency = crossings / 2.0 / ((end - start) / 8000.0);
assertEquals(0.5 / Math.sqrt(2), rms, 0.07, label + " level");
assertEquals(1000, frequency, 30, label + " frequency");
}
@Test
public void readsStreamingMP3() throws Exception
{
for(InputAudioFormat format: new InputAudioFormat[]{InputAudioFormat.SR_16000, InputAudioFormat.SR_8000,
InputAudioFormat.SR_44100})
{
Path path = mTempDir.resolve("call_" + format.name() + ".mp3");
StreamingMP3Writer writer = new StreamingMP3Writer(path, format, MP3Setting.CBR_16, false, Map.of());
writer.write(tone(100));
writer.close(Map.of(AudioMetadata.TRACK_TITLE, "Test"));
float[] samples = RecordingReader.read(path);
assertTone(samples, 16000, "MP3 " + format);
}
}
@Test
public void readsStreamingWave() throws Exception
{
Path path = mTempDir.resolve("call.wav");
StreamingWaveWriter writer = new StreamingWaveWriter(path);
writer.write(tone(100));
writer.close(Map.of(AudioMetadata.TRACK_TITLE, "Test"));
float[] samples = RecordingReader.read(path);
assertEquals(16000, samples.length, "exact length");
assertTone(samples, 16000, "WAVE");
assertTrue(samples.length > 0);
}
}

View File

@@ -1,209 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2026 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.record.stream;
import com.mpatric.mp3agic.ID3v2;
import com.mpatric.mp3agic.Mp3File;
import io.github.dsheirer.audio.convert.InputAudioFormat;
import io.github.dsheirer.audio.convert.MP3Setting;
import io.github.dsheirer.record.wave.AudioMetadata;
import io.github.dsheirer.record.wave.AudioMetadataUtils;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Streaming MP3 and WAVE recordings: audio written in chunks during the call and the final metadata written at close.
*/
public class StreamingAudioWriterTest
{
private static final int BUFFER_SIZE = 160;
@TempDir
Path mTempDir;
/**
* 1 kHz tone at 8 kHz in 20 ms buffers
*/
private static List<float[]> tone(int buffers, float amplitude)
{
List<float[]> audio = new ArrayList<>();
int sample = 0;
for(int x = 0; x < buffers; x++)
{
float[] buffer = new float[BUFFER_SIZE];
for(int y = 0; y < BUFFER_SIZE; y++)
{
buffer[y] = amplitude * (float)Math.sin(2.0 * Math.PI * 1000.0 * sample++ / 8000.0);
}
audio.add(buffer);
}
return audio;
}
private static Map<AudioMetadata,String> metadata(String title)
{
Map<AudioMetadata,String> metadata = new EnumMap<>(AudioMetadata.class);
metadata.put(AudioMetadata.TRACK_TITLE, title);
metadata.put(AudioMetadata.ARTIST_NAME, "Radio 1234");
return metadata;
}
@Test
public void mp3StreamIsPlayableDuringAndAfterTheCall() throws Exception
{
Path path = mTempDir.resolve("call.mp3");
StreamingMP3Writer writer = new StreamingMP3Writer(path, InputAudioFormat.SR_16000, MP3Setting.CBR_16, false,
metadata("Initial"));
List<float[]> audio = tone(250, 0.5f);
//5 seconds of audio written in 10 chunks, like the recorder does during a call
for(int x = 0; x < 10; x++)
{
writer.write(audio.subList(x * 25, (x + 1) * 25));
if(x == 4)
{
assertTrue(Files.size(path) > StreamingMP3Writer.RESERVED_TAG_SIZE, "file grows during the call");
Mp3File partial = new Mp3File(path.toString());
assertTrue(partial.getFrameCount() > 0, "partial recording has audio frames");
}
}
writer.close(metadata("Final Title"));
Mp3File mp3 = new Mp3File(path.toString());
ID3v2 tag = mp3.getId3v2Tag();
assertNotNull(tag);
assertEquals("Final Title", tag.getTitle(), "final metadata replaces the initial tag");
assertEquals("Radio 1234", tag.getArtist());
assertEquals(StreamingMP3Writer.RESERVED_TAG_SIZE, mp3.getStartOffset(), "audio starts after reserved tag");
assertEquals(5000, mp3.getLengthInMilliseconds(), 300, "duration");
}
@Test
public void mp3FinalTagLargerThanReservedSpaceRewritesFile() throws Exception
{
Path path = mTempDir.resolve("long.mp3");
StreamingMP3Writer writer = new StreamingMP3Writer(path, InputAudioFormat.SR_16000, MP3Setting.CBR_16, false,
metadata("Initial"));
writer.write(tone(100, 0.5f));
String longTitle = "T".repeat(StreamingMP3Writer.RESERVED_TAG_SIZE * 2);
writer.close(metadata(longTitle));
Mp3File mp3 = new Mp3File(path.toString());
assertEquals(longTitle, mp3.getId3v2Tag().getTitle());
assertEquals(2000, mp3.getLengthInMilliseconds(), 300);
assertTrue(!Files.exists(path.resolveSibling("long.mp3.tmp")), "temporary file removed");
}
@Test
public void paddedTagKeepsFrames() throws Exception
{
byte[] tag = AudioMetadataUtils.getMP3ID3(metadata("Padded"));
byte[] padded = StreamingMP3Writer.getPaddedTag(tag, 4096);
assertNotNull(padded);
assertEquals(4096, padded.length);
assertNull(StreamingMP3Writer.getPaddedTag(tag, tag.length - 1), "tag doesn't fit");
}
@Test
public void normalizationGainOnlyDecreases()
{
StreamingMP3Writer writer = null;
try
{
writer = new StreamingMP3Writer(mTempDir.resolve("n.mp3"), InputAudioFormat.SR_16000,
MP3Setting.CBR_16, true, metadata("N"));
float[] quiet = tone(1, 0.05f).getFirst();
float[] loud = tone(1, 0.5f).getFirst();
List<float[]> first = writer.normalize(List.of(quiet));
List<float[]> second = writer.normalize(List.of(loud));
List<float[]> third = writer.normalize(List.of(quiet));
assertEquals(0.95f * 0.05f / 0.1f, peak(first.getFirst()), 0.01f, "quiet audio gain limited to 20 dB");
assertEquals(0.95f, peak(second.getFirst()), 0.01f, "loud audio normalized to the target");
assertEquals(0.95f * 0.05f / 0.5f, peak(third.getFirst()), 0.01f, "gain stays at the lower value");
assertEquals(0.05f, peak(quiet), 0.001f, "source buffers aren't modified");
}
catch(Exception e)
{
throw new AssertionError(e);
}
finally
{
if(writer != null)
{
writer.abort();
}
}
}
private static float peak(float[] samples)
{
float peak = 0;
for(float sample: samples)
{
peak = Math.max(peak, Math.abs(sample));
}
return peak;
}
@Test
public void waveStreamIsValidDuringAndAfterTheCall() throws Exception
{
Path path = mTempDir.resolve("call.wav");
StreamingWaveWriter writer = new StreamingWaveWriter(path);
List<float[]> audio = tone(100, 0.5f);
writer.write(audio.subList(0, 50));
try(AudioInputStream partial = AudioSystem.getAudioInputStream(path.toFile()))
{
assertEquals(50 * BUFFER_SIZE, partial.getFrameLength(), "partial file has a valid header");
}
writer.write(audio.subList(50, 100));
writer.close(metadata("Wave"));
try(AudioInputStream stream = AudioSystem.getAudioInputStream(path.toFile()))
{
assertEquals(100 * BUFFER_SIZE, stream.getFrameLength());
}
}
}