_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q7500 | VirtualCdj.deliverTempoChangedAnnouncement | train | private void deliverTempoChangedAnnouncement(final double tempo) {
for (final MasterListener listener : getMasterListeners()) {
try {
listener.tempoChanged(tempo);
} catch (Throwable t) {
logger.warn("Problem delivering tempo changed announcement to listener", t);
}
}
} | java | {
"resource": ""
} |
q7501 | VirtualCdj.deliverBeatAnnouncement | train | private void deliverBeatAnnouncement(final Beat beat) {
for (final MasterListener listener : getMasterListeners()) {
try {
listener.newBeat(beat);
} catch (Throwable t) {
logger.warn("Problem delivering master beat announcement to listener", t);
}
}
} | java | {
"resource": ""
} |
q7502 | VirtualCdj.deliverDeviceUpdate | train | private void deliverDeviceUpdate(final DeviceUpdate update) {
for (DeviceUpdateListener listener : getUpdateListeners()) {
try {
listener.received(update);
} catch (Throwable t) {
logger.warn("Problem delivering device update to listener", t);
}
}
} | java | {
"resource": ""
} |
q7503 | VirtualCdj.deliverMediaDetailsUpdate | train | private void deliverMediaDetailsUpdate(final MediaDetails details) {
for (MediaDetailsListener listener : getMediaDetailsListeners()) {
try {
listener.detailsAvailable(details);
} catch (Throwable t) {
logger.warn("Problem delivering media details response to listener", t);
}
}
} | java | {
"resource": ""
} |
q7504 | VirtualCdj.assembleAndSendPacket | train | @SuppressWarnings("SameParameterValue")
private void assembleAndSendPacket(Util.PacketType kind, byte[] payload, InetAddress destination, int port) throws IOException {
DatagramPacket packet = Util.buildPacket(kind,
ByteBuffer.wrap(announcementBytes, DEVICE_NAME_OFFSET, DEVICE_NAME_LENGTH).asReadOnlyBuffer(),
ByteBuffer.wrap(payload));
packet.setAddress(destination);
packet.setPort(port);
socket.get().send(packet);
} | java | {
"resource": ""
} |
q7505 | VirtualCdj.sendSyncControlCommand | train | private void sendSyncControlCommand(DeviceUpdate target, byte command) throws IOException {
ensureRunning();
byte[] payload = new byte[SYNC_CONTROL_PAYLOAD.length];
System.arraycopy(SYNC_CONTROL_PAYLOAD, 0, payload, 0, SYNC_CONTROL_PAYLOAD.length);
payload[2] = getDeviceNumber();
payload[8] = getDeviceNumber();
payload[12] = command;
assembleAndSendPacket(Util.PacketType.SYNC_CONTROL, payload, target.getAddress(), BeatFinder.BEAT_PORT);
} | java | {
"resource": ""
} |
q7506 | VirtualCdj.sendSyncModeCommand | train | public void sendSyncModeCommand(int deviceNumber, boolean synced) throws IOException {
final DeviceUpdate update = getLatestStatusFor(deviceNumber);
if (update == null) {
throw new IllegalArgumentException("Device " + deviceNumber + " not found on network.");
}
sendSyncModeCommand(update, synced);
} | java | {
"resource": ""
} |
q7507 | VirtualCdj.appointTempoMaster | train | public void appointTempoMaster(int deviceNumber) throws IOException {
final DeviceUpdate update = getLatestStatusFor(deviceNumber);
if (update == null) {
throw new IllegalArgumentException("Device " + deviceNumber + " not found on network.");
}
appointTempoMaster(update);
} | java | {
"resource": ""
} |
q7508 | VirtualCdj.sendFaderStartCommand | train | public void sendFaderStartCommand(Set<Integer> deviceNumbersToStart, Set<Integer> deviceNumbersToStop) throws IOException {
ensureRunning();
byte[] payload = new byte[FADER_START_PAYLOAD.length];
System.arraycopy(FADER_START_PAYLOAD, 0, payload, 0, FADER_START_PAYLOAD.length);
payload[2] = getDeviceNumber();
for (int i = 1; i <= 4; i++) {
if (deviceNumbersToStart.contains(i)) {
payload[i + 4] = 0;
}
if (deviceNumbersToStop.contains(i)) {
payload[i + 4] = 1;
}
}
assembleAndSendPacket(Util.PacketType.FADER_START_COMMAND, payload, getBroadcastAddress(), BeatFinder.BEAT_PORT);
} | java | {
"resource": ""
} |
q7509 | VirtualCdj.sendLoadTrackCommand | train | public void sendLoadTrackCommand(int targetPlayer, int rekordboxId,
int sourcePlayer, CdjStatus.TrackSourceSlot sourceSlot, CdjStatus.TrackType sourceType)
throws IOException {
final DeviceUpdate update = getLatestStatusFor(targetPlayer);
if (update == null) {
throw new IllegalArgumentException("Device " + targetPlayer + " not found on network.");
}
sendLoadTrackCommand(update, rekordboxId, sourcePlayer, sourceSlot, sourceType);
} | java | {
"resource": ""
} |
q7510 | VirtualCdj.sendLoadTrackCommand | train | public void sendLoadTrackCommand(DeviceUpdate target, int rekordboxId,
int sourcePlayer, CdjStatus.TrackSourceSlot sourceSlot, CdjStatus.TrackType sourceType)
throws IOException {
ensureRunning();
byte[] payload = new byte[LOAD_TRACK_PAYLOAD.length];
System.arraycopy(LOAD_TRACK_PAYLOAD, 0, payload, 0, LOAD_TRACK_PAYLOAD.length);
payload[0x02] = getDeviceNumber();
payload[0x05] = getDeviceNumber();
payload[0x09] = (byte)sourcePlayer;
payload[0x0a] = sourceSlot.protocolValue;
payload[0x0b] = sourceType.protocolValue;
Util.numberToBytes(rekordboxId, payload, 0x0d, 4);
assembleAndSendPacket(Util.PacketType.LOAD_TRACK_COMMAND, payload, target.getAddress(), UPDATE_PORT);
} | java | {
"resource": ""
} |
q7511 | VirtualCdj.setSendingStatus | train | public synchronized void setSendingStatus(boolean send) throws IOException {
if (isSendingStatus() == send) {
return;
}
if (send) { // Start sending status packets.
ensureRunning();
if ((getDeviceNumber() < 1) || (getDeviceNumber() > 4)) {
throw new IllegalStateException("Can only send status when using a standard player number, 1 through 4.");
}
BeatFinder.getInstance().start();
BeatFinder.getInstance().addLifecycleListener(beatFinderLifecycleListener);
final AtomicBoolean stillRunning = new AtomicBoolean(true);
sendingStatus = stillRunning; // Allow other threads to stop us when necessary.
Thread sender = new Thread(null, new Runnable() {
@Override
public void run() {
while (stillRunning.get()) {
sendStatus();
try {
Thread.sleep(getStatusInterval());
} catch (InterruptedException e) {
logger.warn("beat-link VirtualCDJ status sender thread was interrupted; continuing");
}
}
}
}, "beat-link VirtualCdj status sender");
sender.setDaemon(true);
sender.start();
if (isSynced()) { // If we are supposed to be synced, we need to respond to master beats and tempo changes.
addMasterListener(ourSyncMasterListener);
}
if (isPlaying()) { // Start the beat sender too, if we are supposed to be playing.
beatSender.set(new BeatSender(metronome));
}
} else { // Stop sending status packets, and responding to master beats and tempo changes if we were synced.
BeatFinder.getInstance().removeLifecycleListener(beatFinderLifecycleListener);
removeMasterListener(ourSyncMasterListener);
sendingStatus.set(false); // Stop the status sending thread.
sendingStatus = null; // Indicate that we are no longer sending status.
final BeatSender activeSender = beatSender.get(); // And stop the beat sender if we have one.
if (activeSender != null) {
activeSender.shutDown();
beatSender.set(null);
}
}
} | java | {
"resource": ""
} |
q7512 | VirtualCdj.setPlaying | train | public void setPlaying(boolean playing) {
if (this.playing.get() == playing) {
return;
}
this.playing.set(playing);
if (playing) {
metronome.jumpToBeat(whereStopped.get().getBeat());
if (isSendingStatus()) { // Need to also start the beat sender.
beatSender.set(new BeatSender(metronome));
}
} else {
final BeatSender activeSender = beatSender.get();
if (activeSender != null) { // We have a beat sender we need to stop.
activeSender.shutDown();
beatSender.set(null);
}
whereStopped.set(metronome.getSnapshot());
}
} | java | {
"resource": ""
} |
q7513 | VirtualCdj.becomeTempoMaster | train | public synchronized void becomeTempoMaster() throws IOException {
logger.debug("Trying to become master.");
if (!isSendingStatus()) {
throw new IllegalStateException("Must be sending status updates to become the tempo master.");
}
// Is there someone we need to ask to yield to us?
final DeviceUpdate currentMaster = getTempoMaster();
if (currentMaster != null) {
// Send the yield request; we will become master when we get a successful response.
byte[] payload = new byte[MASTER_HANDOFF_REQUEST_PAYLOAD.length];
System.arraycopy(MASTER_HANDOFF_REQUEST_PAYLOAD, 0, payload, 0, MASTER_HANDOFF_REQUEST_PAYLOAD.length);
payload[2] = getDeviceNumber();
payload[8] = getDeviceNumber();
if (logger.isDebugEnabled()) {
logger.debug("Sending master yield request to player " + currentMaster);
}
requestingMasterRoleFromPlayer.set(currentMaster.deviceNumber);
assembleAndSendPacket(Util.PacketType.MASTER_HANDOFF_REQUEST, payload, currentMaster.address, BeatFinder.BEAT_PORT);
} else if (!master.get()) {
// There is no other master, we can just become it immediately.
requestingMasterRoleFromPlayer.set(0);
setMasterTempo(getTempo());
master.set(true);
}
} | java | {
"resource": ""
} |
q7514 | VirtualCdj.setSynced | train | public synchronized void setSynced(boolean sync) {
if (synced.get() != sync) {
// We are changing sync state, so add or remove our master listener as appropriate.
if (sync && isSendingStatus()) {
addMasterListener(ourSyncMasterListener);
} else {
removeMasterListener(ourSyncMasterListener);
}
// Also, if there is a tempo master, and we just got synced, adopt its tempo.
if (!isTempoMaster() && getTempoMaster() != null) {
setTempo(getMasterTempo());
}
}
synced.set(sync);
} | java | {
"resource": ""
} |
q7515 | VirtualCdj.jumpToBeat | train | public synchronized void jumpToBeat(int beat) {
if (beat < 1) {
beat = 1;
} else {
beat = wrapBeat(beat);
}
if (playing.get()) {
metronome.jumpToBeat(beat);
} else {
whereStopped.set(metronome.getSnapshot(metronome.getTimeOfBeat(beat)));
}
} | java | {
"resource": ""
} |
q7516 | WaveformDetailComponent.getPlaybackState | train | public Set<PlaybackState> getPlaybackState() {
Set<PlaybackState> result = new HashSet<PlaybackState>(playbackStateMap.values());
return Collections.unmodifiableSet(result);
} | java | {
"resource": ""
} |
q7517 | WaveformDetailComponent.setPlaybackPosition | train | private void setPlaybackPosition(long milliseconds) {
PlaybackState oldState = currentSimpleState();
if (oldState != null && oldState.position != milliseconds) {
setPlaybackState(oldState.player, milliseconds, oldState.playing);
}
} | java | {
"resource": ""
} |
q7518 | WaveformDetailComponent.setPlaying | train | private void setPlaying(boolean playing) {
PlaybackState oldState = currentSimpleState();
if (oldState != null && oldState.playing != playing) {
setPlaybackState(oldState.player, oldState.position, playing);
}
} | java | {
"resource": ""
} |
q7519 | WaveformDetailComponent.setMonitoredPlayer | train | public synchronized void setMonitoredPlayer(final int player) {
if (player < 0) {
throw new IllegalArgumentException("player cannot be negative");
}
clearPlaybackState();
monitoredPlayer.set(player);
if (player > 0) { // Start monitoring the specified player
setPlaybackState(player, 0, false); // Start with default values for required simple state.
VirtualCdj.getInstance().addUpdateListener(updateListener);
MetadataFinder.getInstance().addTrackMetadataListener(metadataListener);
cueList.set(null); // Assume the worst, but see if we have one available next.
if (MetadataFinder.getInstance().isRunning()) {
TrackMetadata metadata = MetadataFinder.getInstance().getLatestMetadataFor(player);
if (metadata != null) {
cueList.set(metadata.getCueList());
}
}
WaveformFinder.getInstance().addWaveformListener(waveformListener);
if (WaveformFinder.getInstance().isRunning() && WaveformFinder.getInstance().isFindingDetails()) {
waveform.set(WaveformFinder.getInstance().getLatestDetailFor(player));
} else {
waveform.set(null);
}
BeatGridFinder.getInstance().addBeatGridListener(beatGridListener);
if (BeatGridFinder.getInstance().isRunning()) {
beatGrid.set(BeatGridFinder.getInstance().getLatestBeatGridFor(player));
} else {
beatGrid.set(null);
}
try {
TimeFinder.getInstance().start();
if (!animating.getAndSet(true)) {
// Create the thread to update our position smoothly as the track plays
new Thread(new Runnable() {
@Override
public void run() {
while (animating.get()) {
try {
Thread.sleep(33); // Animate at 30 fps
} catch (InterruptedException e) {
logger.warn("Waveform animation thread interrupted; ending");
animating.set(false);
}
setPlaybackPosition(TimeFinder.getInstance().getTimeFor(getMonitoredPlayer()));
}
}
}).start();
}
} catch (Exception e) {
logger.error("Unable to start the TimeFinder to animate the waveform detail view");
animating.set(false);
}
} else { // Stop monitoring any player
animating.set(false);
VirtualCdj.getInstance().removeUpdateListener(updateListener);
MetadataFinder.getInstance().removeTrackMetadataListener(metadataListener);
WaveformFinder.getInstance().removeWaveformListener(waveformListener);
cueList.set(null);
waveform.set(null);
beatGrid.set(null);
}
if (!autoScroll.get()) {
invalidate();
}
repaint();
} | java | {
"resource": ""
} |
q7520 | WaveformDetailComponent.getFurthestPlaybackState | train | public PlaybackState getFurthestPlaybackState() {
PlaybackState result = null;
for (PlaybackState state : playbackStateMap.values()) {
if (result == null || (!result.playing && state.playing) ||
(result.position < state.position) && (state.playing || !result.playing)) {
result = state;
}
}
return result;
} | java | {
"resource": ""
} |
q7521 | WaveformDetailComponent.getSegmentForX | train | private int getSegmentForX(int x) {
if (autoScroll.get()) {
int playHead = (x - (getWidth() / 2));
int offset = Util.timeToHalfFrame(getFurthestPlaybackPosition()) / scale.get();
return (playHead + offset) * scale.get();
}
return x * scale.get();
} | java | {
"resource": ""
} |
q7522 | WaveformDetailComponent.getXForBeat | train | public int getXForBeat(int beat) {
BeatGrid grid = beatGrid.get();
if (grid != null) {
return millisecondsToX(grid.getTimeWithinTrack(beat));
}
return 0;
} | java | {
"resource": ""
} |
q7523 | WaveformDetailComponent.millisecondsToX | train | public int millisecondsToX(long milliseconds) {
if (autoScroll.get()) {
int playHead = (getWidth() / 2) + 2;
long offset = milliseconds - getFurthestPlaybackPosition();
return playHead + (Util.timeToHalfFrame(offset) / scale.get());
}
return Util.timeToHalfFrame(milliseconds) / scale.get();
} | java | {
"resource": ""
} |
q7524 | WaveformDetailComponent.cueColor | train | public static Color cueColor(CueList.Entry entry) {
if (entry.hotCueNumber > 0) {
return Color.GREEN;
}
if (entry.isLoop) {
return Color.ORANGE;
}
return Color.RED;
} | java | {
"resource": ""
} |
q7525 | DeviceUpdate.getPacketBytes | train | public byte[] getPacketBytes() {
byte[] result = new byte[packetBytes.length];
System.arraycopy(packetBytes, 0, result, 0, packetBytes.length);
return result;
} | java | {
"resource": ""
} |
q7526 | Util.buildPacket | train | public static DatagramPacket buildPacket(PacketType type, ByteBuffer deviceName, ByteBuffer payload) {
ByteBuffer content = ByteBuffer.allocate(0x1f + payload.remaining());
content.put(getMagicHeader());
content.put(type.protocolValue);
content.put(deviceName);
content.put(payload);
return new DatagramPacket(content.array(), content.capacity());
} | java | {
"resource": ""
} |
q7527 | Util.validateHeader | train | public static PacketType validateHeader(DatagramPacket packet, int port) {
byte[] data = packet.getData();
if (data.length < PACKET_TYPE_OFFSET) {
logger.warn("Packet is too short to be a Pro DJ Link packet; must be at least " + PACKET_TYPE_OFFSET +
" bytes long, was only " + data.length + ".");
return null;
}
if (!getMagicHeader().equals(ByteBuffer.wrap(data, 0, MAGIC_HEADER.length))) {
logger.warn("Packet did not have correct nine-byte header for the Pro DJ Link protocol.");
return null;
}
final Map<Byte, PacketType> portMap = PACKET_TYPE_MAP.get(port);
if (portMap == null) {
logger.warn("Do not know any Pro DJ Link packets that are received on port " + port + ".");
return null;
}
final PacketType result = portMap.get(data[PACKET_TYPE_OFFSET]);
if (result == null) {
logger.warn("Do not know any Pro DJ Link packets received on port " + port + " with type " +
String.format("0x%02x", data[PACKET_TYPE_OFFSET]) + ".");
}
return result;
} | java | {
"resource": ""
} |
q7528 | Util.bytesToNumber | train | public static long bytesToNumber(byte[] buffer, int start, int length) {
long result = 0;
for (int index = start; index < start + length; index++) {
result = (result << 8) + unsign(buffer[index]);
}
return result;
} | java | {
"resource": ""
} |
q7529 | Util.bytesToNumberLittleEndian | train | @SuppressWarnings("SameParameterValue")
public static long bytesToNumberLittleEndian(byte[] buffer, int start, int length) {
long result = 0;
for (int index = start + length - 1; index >= start; index--) {
result = (result << 8) + unsign(buffer[index]);
}
return result;
} | java | {
"resource": ""
} |
q7530 | Util.numberToBytes | train | public static void numberToBytes(int number, byte[] buffer, int start, int length) {
for (int index = start + length - 1; index >= start; index--) {
buffer[index] = (byte)(number & 0xff);
number = number >> 8;
}
} | java | {
"resource": ""
} |
q7531 | Util.addressToLong | train | public static long addressToLong(InetAddress address) {
long result = 0;
for (byte element : address.getAddress()) {
result = (result << 8) + unsign(element);
}
return result;
} | java | {
"resource": ""
} |
q7532 | Util.sameNetwork | train | public static boolean sameNetwork(int prefixLength, InetAddress address1, InetAddress address2) {
if (logger.isDebugEnabled()) {
logger.debug("Comparing address " + address1.getHostAddress() + " with " + address2.getHostAddress() + ", prefixLength=" + prefixLength);
}
long prefixMask = 0xffffffffL & (-1 << (32 - prefixLength));
return (addressToLong(address1) & prefixMask) == (addressToLong(address2) & prefixMask);
} | java | {
"resource": ""
} |
q7533 | Util.writeFully | train | public static void writeFully(ByteBuffer buffer, WritableByteChannel channel) throws IOException {
while (buffer.hasRemaining()) {
channel.write(buffer);
}
} | java | {
"resource": ""
} |
q7534 | SignatureFinder.getSignatures | train | public Map<Integer, String> getSignatures() {
ensureRunning();
// Make a copy so callers get an immutable snapshot of the current state.
return Collections.unmodifiableMap(new HashMap<Integer, String>(signatures));
} | java | {
"resource": ""
} |
q7535 | SignatureFinder.checkExistingTracks | train | private void checkExistingTracks() {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
for (Map.Entry<DeckReference, TrackMetadata> entry : MetadataFinder.getInstance().getLoadedTracks().entrySet()) {
if (entry.getKey().hotCue == 0) { // The track is currently loaded in a main player deck
checkIfSignatureReady(entry.getKey().player);
}
}
}
});
} | java | {
"resource": ""
} |
q7536 | SignatureFinder.digestInteger | train | private void digestInteger(MessageDigest digest, int value) {
byte[] valueBytes = new byte[4];
Util.numberToBytes(value, valueBytes, 0, 4);
digest.update(valueBytes);
} | java | {
"resource": ""
} |
q7537 | SignatureFinder.computeTrackSignature | train | public String computeTrackSignature(final String title, final SearchableItem artist, final int duration,
final WaveformDetail waveformDetail, final BeatGrid beatGrid) {
final String safeTitle = (title == null)? "" : title;
final String artistName = (artist == null)? "[no artist]" : artist.label;
try {
// Compute the SHA-1 hash of our fields
MessageDigest digest = MessageDigest.getInstance("SHA1");
digest.update(safeTitle.getBytes("UTF-8"));
digest.update((byte) 0);
digest.update(artistName.getBytes("UTF-8"));
digest.update((byte) 0);
digestInteger(digest, duration);
digest.update(waveformDetail.getData());
for (int i = 1; i <= beatGrid.beatCount; i++) {
digestInteger(digest, beatGrid.getBeatWithinBar(i));
digestInteger(digest, (int)beatGrid.getTimeWithinTrack(i));
}
byte[] result = digest.digest();
// Create a hex string representation of the hash
StringBuilder hex = new StringBuilder(result.length * 2);
for (byte aResult : result) {
hex.append(Integer.toString((aResult & 0xff) + 0x100, 16).substring(1));
}
return hex.toString();
} catch (NullPointerException e) {
logger.info("Returning null track signature because an input element was null.", e);
} catch (NoSuchAlgorithmException e) {
logger.error("Unable to obtain SHA-1 MessageDigest instance for computing track signatures.", e);
} catch (UnsupportedEncodingException e) {
logger.error("Unable to work with UTF-8 string encoding for computing track signatures.", e);
}
return null; // We were unable to compute a signature
} | java | {
"resource": ""
} |
q7538 | SignatureFinder.handleUpdate | train | private void handleUpdate(final int player) {
final TrackMetadata metadata = MetadataFinder.getInstance().getLatestMetadataFor(player);
final WaveformDetail waveformDetail = WaveformFinder.getInstance().getLatestDetailFor(player);
final BeatGrid beatGrid = BeatGridFinder.getInstance().getLatestBeatGridFor(player);
if (metadata != null && waveformDetail != null && beatGrid != null) {
final String signature = computeTrackSignature(metadata.getTitle(), metadata.getArtist(),
metadata.getDuration(), waveformDetail, beatGrid);
if (signature != null) {
signatures.put(player, signature);
deliverSignatureUpdate(player, signature);
}
}
} | java | {
"resource": ""
} |
q7539 | SignatureFinder.stop | train | public synchronized void stop () {
if (isRunning()) {
MetadataFinder.getInstance().removeTrackMetadataListener(metadataListener);
WaveformFinder.getInstance().removeWaveformListener(waveformListener);
BeatGridFinder.getInstance().removeBeatGridListener(beatGridListener);
running.set(false);
pendingUpdates.clear();
queueHandler.interrupt();
queueHandler = null;
// Report the loss of our signatures, on the proper thread, outside our lock
final Set<Integer> dyingSignatures = new HashSet<Integer>(signatures.keySet());
signatures.clear();
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
for (Integer player : dyingSignatures) {
deliverSignatureUpdate(player, null);
}
}
});
}
deliverLifecycleAnnouncement(logger, false);
} | java | {
"resource": ""
} |
q7540 | DeviceFinder.expireDevices | train | private void expireDevices() {
long now = System.currentTimeMillis();
// Make a copy so we don't have to worry about concurrent modification.
Map<InetAddress, DeviceAnnouncement> copy = new HashMap<InetAddress, DeviceAnnouncement>(devices);
for (Map.Entry<InetAddress, DeviceAnnouncement> entry : copy.entrySet()) {
if (now - entry.getValue().getTimestamp() > MAXIMUM_AGE) {
devices.remove(entry.getKey());
deliverLostAnnouncement(entry.getValue());
}
}
if (devices.isEmpty()) {
firstDeviceTime.set(0); // We have lost contact with the Pro DJ Link network, so start over with next device.
}
} | java | {
"resource": ""
} |
q7541 | DeviceFinder.updateDevices | train | private void updateDevices(DeviceAnnouncement announcement) {
firstDeviceTime.compareAndSet(0, System.currentTimeMillis());
devices.put(announcement.getAddress(), announcement);
} | java | {
"resource": ""
} |
q7542 | DeviceFinder.start | train | public synchronized void start() throws SocketException {
if (!isRunning()) {
socket.set(new DatagramSocket(ANNOUNCEMENT_PORT));
startTime.set(System.currentTimeMillis());
deliverLifecycleAnnouncement(logger, true);
final byte[] buffer = new byte[512];
final DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
Thread receiver = new Thread(null, new Runnable() {
@Override
public void run() {
boolean received;
while (isRunning()) {
try {
if (getCurrentDevices().isEmpty()) {
socket.get().setSoTimeout(60000); // We have no devices to check for timeout; block for a whole minute to check for shutdown
} else {
socket.get().setSoTimeout(1000); // Check every second to see if a device has vanished
}
socket.get().receive(packet);
received = !ignoredAddresses.contains(packet.getAddress());
} catch (SocketTimeoutException ste) {
received = false;
} catch (IOException e) {
// Don't log a warning if the exception was due to the socket closing at shutdown.
if (isRunning()) {
// We did not expect to have a problem; log a warning and shut down.
logger.warn("Problem reading from DeviceAnnouncement socket, stopping", e);
stop();
}
received = false;
}
try {
if (received && (packet.getLength() == 54)) {
final Util.PacketType kind = Util.validateHeader(packet, ANNOUNCEMENT_PORT);
if (kind == Util.PacketType.DEVICE_KEEP_ALIVE) {
// Looks like the kind of packet we need
if (packet.getLength() < 54) {
logger.warn("Ignoring too-short " + kind.name + " packet; expected 54 bytes, but only got " +
packet.getLength() + ".");
} else {
if (packet.getLength() > 54) {
logger.warn("Processing too-long " + kind.name + " packet; expected 54 bytes, but got " +
packet.getLength() + ".");
}
DeviceAnnouncement announcement = new DeviceAnnouncement(packet);
final boolean foundNewDevice = isDeviceNew(announcement);
updateDevices(announcement);
if (foundNewDevice) {
deliverFoundAnnouncement(announcement);
}
}
}
}
expireDevices();
} catch (Throwable t) {
logger.warn("Problem processing DeviceAnnouncement packet", t);
}
}
}
}, "beat-link DeviceFinder receiver");
receiver.setDaemon(true);
receiver.start();
}
} | java | {
"resource": ""
} |
q7543 | DeviceFinder.stop | train | @SuppressWarnings("WeakerAccess")
public synchronized void stop() {
if (isRunning()) {
final Set<DeviceAnnouncement> lastDevices = getCurrentDevices();
socket.get().close();
socket.set(null);
devices.clear();
firstDeviceTime.set(0);
// Report the loss of all our devices, on the proper thread, outside our lock
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
for (DeviceAnnouncement announcement : lastDevices) {
deliverLostAnnouncement(announcement);
}
}
});
deliverLifecycleAnnouncement(logger, false);
}
} | java | {
"resource": ""
} |
q7544 | DeviceFinder.deliverFoundAnnouncement | train | private void deliverFoundAnnouncement(final DeviceAnnouncement announcement) {
for (final DeviceAnnouncementListener listener : getDeviceAnnouncementListeners()) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
try {
listener.deviceFound(announcement);
} catch (Throwable t) {
logger.warn("Problem delivering device found announcement to listener", t);
}
}
});
}
} | java | {
"resource": ""
} |
q7545 | DeviceFinder.deliverLostAnnouncement | train | private void deliverLostAnnouncement(final DeviceAnnouncement announcement) {
for (final DeviceAnnouncementListener listener : getDeviceAnnouncementListeners()) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
try {
listener.deviceLost(announcement);
} catch (Throwable t) {
logger.warn("Problem delivering device lost announcement to listener", t);
}
}
});
}
} | java | {
"resource": ""
} |
q7546 | Client.performSetupExchange | train | private void performSetupExchange() throws IOException {
Message setupRequest = new Message(0xfffffffeL, Message.KnownType.SETUP_REQ, new NumberField(posingAsPlayer, 4));
sendMessage(setupRequest);
Message response = Message.read(is);
if (response.knownType != Message.KnownType.MENU_AVAILABLE) {
throw new IOException("Did not receive message type 0x4000 in response to setup message, got: " + response);
}
if (response.arguments.size() != 2) {
throw new IOException("Did not receive two arguments in response to setup message, got: " + response);
}
final Field player = response.arguments.get(1);
if (!(player instanceof NumberField)) {
throw new IOException("Second argument in response to setup message was not a number: " + response);
}
if (((NumberField)player).getValue() != targetPlayer) {
throw new IOException("Expected to connect to player " + targetPlayer +
", but welcome response identified itself as player " + ((NumberField)player).getValue());
}
} | java | {
"resource": ""
} |
q7547 | Client.performTeardownExchange | train | private void performTeardownExchange() throws IOException {
Message teardownRequest = new Message(0xfffffffeL, Message.KnownType.TEARDOWN_REQ);
sendMessage(teardownRequest);
// At this point, the server closes the connection from its end, so we can’t read any more.
} | java | {
"resource": ""
} |
q7548 | Client.close | train | void close() {
try {
performTeardownExchange();
} catch (IOException e) {
logger.warn("Problem reporting our intention to close the dbserver connection", e);
}
try {
channel.close();
} catch (IOException e) {
logger.warn("Problem closing dbserver client output channel", e);
}
try {
os.close();
} catch (IOException e) {
logger.warn("Problem closing dbserver client output stream", e);
}
try {
is.close();
} catch (IOException e) {
logger.warn("Problem closing dbserver client input stream", e);
}
try {
socket.close();
} catch (IOException e) {
logger.warn("Problem closing dbserver client socket", e);
}
} | java | {
"resource": ""
} |
q7549 | Client.sendField | train | @SuppressWarnings("SameParameterValue")
private void sendField(Field field) throws IOException {
if (isConnected()) {
try {
field.write(channel);
} catch (IOException e) {
logger.warn("Problem trying to write field to dbserver, closing connection", e);
close();
throw e;
}
return;
}
throw new IOException("sendField() called after dbserver connection was closed");
} | java | {
"resource": ""
} |
q7550 | Client.sendMessage | train | private void sendMessage(Message message) throws IOException {
logger.debug("Sending> {}", message);
int totalSize = 0;
for (Field field : message.fields) {
totalSize += field.getBytes().remaining();
}
ByteBuffer combined = ByteBuffer.allocate(totalSize);
for (Field field : message.fields) {
logger.debug("..sending> {}", field);
combined.put(field.getBytes());
}
combined.flip();
Util.writeFully(combined, channel);
} | java | {
"resource": ""
} |
q7551 | Client.simpleRequest | train | public synchronized Message simpleRequest(Message.KnownType requestType, Message.KnownType responseType,
Field... arguments)
throws IOException {
final NumberField transaction = assignTransactionNumber();
final Message request = new Message(transaction, new NumberField(requestType.protocolValue, 2), arguments);
sendMessage(request);
final Message response = Message.read(is);
if (response.transaction.getValue() != transaction.getValue()) {
throw new IOException("Received response with wrong transaction ID. Expected: " + transaction.getValue() +
", got: " + response);
}
if (responseType != null && response.knownType != responseType) {
throw new IOException("Received response with wrong type. Expected: " + responseType +
", got: " + response);
}
return response;
} | java | {
"resource": ""
} |
q7552 | Client.menuRequestTyped | train | public synchronized Message menuRequestTyped(Message.KnownType requestType, Message.MenuIdentifier targetMenu,
CdjStatus.TrackSourceSlot slot, CdjStatus.TrackType trackType, Field... arguments)
throws IOException {
if (!menuLock.isHeldByCurrentThread()) {
throw new IllegalStateException("renderMenuItems() cannot be called without first successfully calling tryLockingForMenuOperation()");
}
Field[] combinedArguments = new Field[arguments.length + 1];
combinedArguments[0] = buildRMST(targetMenu, slot, trackType);
System.arraycopy(arguments, 0, combinedArguments, 1, arguments.length);
final Message response = simpleRequest(requestType, Message.KnownType.MENU_AVAILABLE, combinedArguments);
final NumberField reportedRequestType = (NumberField)response.arguments.get(0);
if (reportedRequestType.getValue() != requestType.protocolValue) {
throw new IOException("Menu request did not return result for same type as request; sent type: " +
requestType.protocolValue + ", received type: " + reportedRequestType.getValue() +
", response: " + response);
}
return response;
} | java | {
"resource": ""
} |
q7553 | SlotReference.getSlotReference | train | @SuppressWarnings("WeakerAccess")
public static synchronized SlotReference getSlotReference(int player, CdjStatus.TrackSourceSlot slot) {
Map<CdjStatus.TrackSourceSlot, SlotReference> playerMap = instances.get(player);
if (playerMap == null) {
playerMap = new HashMap<CdjStatus.TrackSourceSlot, SlotReference>();
instances.put(player, playerMap);
}
SlotReference result = playerMap.get(slot);
if (result == null) {
result = new SlotReference(player, slot);
playerMap.put(slot, result);
}
return result;
} | java | {
"resource": ""
} |
q7554 | SlotReference.getSlotReference | train | @SuppressWarnings("WeakerAccess")
public static SlotReference getSlotReference(DataReference dataReference) {
return getSlotReference(dataReference.player, dataReference.slot);
} | java | {
"resource": ""
} |
q7555 | Beat.isTempoMaster | train | @Override
public boolean isTempoMaster() {
DeviceUpdate master = VirtualCdj.getInstance().getTempoMaster();
return (master != null) && master.getAddress().equals(address);
} | java | {
"resource": ""
} |
q7556 | LifecycleParticipant.deliverLifecycleAnnouncement | train | protected void deliverLifecycleAnnouncement(final Logger logger, final boolean starting) {
new Thread(new Runnable() {
@Override
public void run() {
for (final LifecycleListener listener : getLifecycleListeners()) {
try {
if (starting) {
listener.started(LifecycleParticipant.this);
} else {
listener.stopped(LifecycleParticipant.this);
}
} catch (Throwable t) {
logger.warn("Problem delivering lifecycle announcement to listener", t);
}
}
}
}, "Lifecycle announcement delivery").start();
} | java | {
"resource": ""
} |
q7557 | CrateDigger.mountPath | train | private String mountPath(CdjStatus.TrackSourceSlot slot) {
switch (slot) {
case SD_SLOT: return "/B/";
case USB_SLOT: return "/C/";
}
throw new IllegalArgumentException("Don't know how to NFS mount filesystem for slot " + slot);
} | java | {
"resource": ""
} |
q7558 | CrateDigger.deliverDatabaseUpdate | train | private void deliverDatabaseUpdate(SlotReference slot, Database database, boolean available) {
for (final DatabaseListener listener : getDatabaseListeners()) {
try {
if (available) {
listener.databaseMounted(slot, database);
} else {
listener.databaseUnmounted(slot, database);
}
} catch (Throwable t) {
logger.warn("Problem delivering rekordbox database availability update to listener", t);
}
}
} | java | {
"resource": ""
} |
q7559 | WaveformPreviewComponent.delegatingRepaint | train | @SuppressWarnings("SameParameterValue")
private void delegatingRepaint(int x, int y, int width, int height) {
final RepaintDelegate delegate = repaintDelegate.get();
if (delegate != null) {
//logger.info("Delegating repaint: " + x + ", " + y + ", " + width + ", " + height);
delegate.repaint(x, y, width, height);
} else {
//logger.info("Normal repaint: " + x + ", " + y + ", " + width + ", " + height);
repaint(x, y, width, height);
}
} | java | {
"resource": ""
} |
q7560 | WaveformPreviewComponent.updateWaveform | train | private void updateWaveform(WaveformPreview preview) {
this.preview.set(preview);
if (preview == null) {
waveformImage.set(null);
} else {
BufferedImage image = new BufferedImage(preview.segmentCount, preview.maxHeight, BufferedImage.TYPE_INT_RGB);
Graphics g = image.getGraphics();
g.setColor(Color.BLACK);
g.fillRect(0, 0, preview.segmentCount, preview.maxHeight);
for (int segment = 0; segment < preview.segmentCount; segment++) {
g.setColor(preview.segmentColor(segment, false));
g.drawLine(segment, preview.maxHeight, segment, preview.maxHeight - preview.segmentHeight(segment, false));
if (preview.isColor) { // We have a front color segment to draw on top.
g.setColor(preview.segmentColor(segment, true));
g.drawLine(segment, preview.maxHeight, segment, preview.maxHeight - preview.segmentHeight(segment, true));
}
}
waveformImage.set(image);
}
} | java | {
"resource": ""
} |
q7561 | WaveformPreview.getMaxHeight | train | private int getMaxHeight() {
int result = 0;
for (int i = 0; i < segmentCount; i++) {
result = Math.max(result, segmentHeight(i, false));
}
return result;
} | java | {
"resource": ""
} |
q7562 | WaveformPreview.segmentHeight | train | @SuppressWarnings("WeakerAccess")
public int segmentHeight(final int segment, final boolean front) {
final ByteBuffer bytes = getData();
if (isColor) {
final int base = segment * 6;
final int frontHeight = Util.unsign(bytes.get(base + 5));
if (front) {
return frontHeight;
} else {
return Math.max(frontHeight, Math.max(Util.unsign(bytes.get(base + 3)), Util.unsign(bytes.get(base + 4))));
}
} else {
return getData().get(segment * 2) & 0x1f;
}
} | java | {
"resource": ""
} |
q7563 | WaveformPreview.segmentColor | train | @SuppressWarnings("WeakerAccess")
public Color segmentColor(final int segment, final boolean front) {
final ByteBuffer bytes = getData();
if (isColor) {
final int base = segment * 6;
final int backHeight = segmentHeight(segment, false);
if (backHeight == 0) {
return Color.BLACK;
}
final int maxLevel = front? 255 : 191;
final int red = Util.unsign(bytes.get(base + 3)) * maxLevel / backHeight;
final int green = Util.unsign(bytes.get(base + 4)) * maxLevel / backHeight;
final int blue = Util.unsign(bytes.get(base + 5)) * maxLevel / backHeight;
return new Color(red, green, blue);
} else {
final int intensity = getData().get(segment * 2 + 1) & 0x07;
return (intensity >= 5) ? INTENSE_COLOR : NORMAL_COLOR;
}
} | java | {
"resource": ""
} |
q7564 | MediaDetails.hasChanged | train | public boolean hasChanged(MediaDetails originalMedia) {
if (!hashKey().equals(originalMedia.hashKey())) {
throw new IllegalArgumentException("Can't compare media details with different hashKey values");
}
return playlistCount != originalMedia.playlistCount || trackCount != originalMedia.trackCount;
} | java | {
"resource": ""
} |
q7565 | BinaryField.getValueAsArray | train | public byte[] getValueAsArray() {
ByteBuffer buffer = getValue();
byte[] result = new byte[buffer.remaining()];
buffer.get(result);
return result;
} | java | {
"resource": ""
} |
q7566 | CueList.getHotCueCount | train | public int getHotCueCount() {
if (rawMessage != null) {
return (int) ((NumberField) rawMessage.arguments.get(5)).getValue();
}
int total = 0;
for (Entry entry : entries) {
if (entry.hotCueNumber > 0) {
++total;
}
}
return total;
} | java | {
"resource": ""
} |
q7567 | CueList.sortEntries | train | private List<Entry> sortEntries(List<Entry> loadedEntries) {
Collections.sort(loadedEntries, new Comparator<Entry>() {
@Override
public int compare(Entry entry1, Entry entry2) {
int result = (int) (entry1.cuePosition - entry2.cuePosition);
if (result == 0) {
int h1 = (entry1.hotCueNumber != 0) ? 1 : 0;
int h2 = (entry2.hotCueNumber != 0) ? 1 : 0;
result = h1 - h2;
}
return result;
}
});
return Collections.unmodifiableList(loadedEntries);
} | java | {
"resource": ""
} |
q7568 | CueList.addEntriesFromTag | train | private void addEntriesFromTag(List<Entry> entries, RekordboxAnlz.CueTag tag) {
for (RekordboxAnlz.CueEntry cueEntry : tag.cues()) { // TODO: Need to figure out how to identify deleted entries to ignore.
if (cueEntry.type() == RekordboxAnlz.CueEntryType.LOOP) {
entries.add(new Entry((int)cueEntry.hotCue(), Util.timeToHalfFrame(cueEntry.time()),
Util.timeToHalfFrame(cueEntry.loopTime())));
} else {
entries.add(new Entry((int)cueEntry.hotCue(), Util.timeToHalfFrame(cueEntry.time())));
}
}
} | java | {
"resource": ""
} |
q7569 | Processor.process | train | public final static String process(final String input, final Configuration configuration)
{
try
{
return process(new StringReader(input), configuration);
}
catch (final IOException e)
{
// This _can never_ happen
return null;
}
} | java | {
"resource": ""
} |
q7570 | Processor.process | train | public final static String process(final File file, final Configuration configuration) throws IOException
{
final FileInputStream input = new FileInputStream(file);
final String ret = process(input, configuration);
input.close();
return ret;
} | java | {
"resource": ""
} |
q7571 | Processor.process | train | public final static String process(final File file, final boolean safeMode) throws IOException
{
return process(file, Configuration.builder().setSafeMode(safeMode).build());
} | java | {
"resource": ""
} |
q7572 | Run.main | train | public static void main(final String[] args) throws IOException
{
// This is just a _hack_ ...
BufferedReader reader = null;
if (args.length == 0)
{
System.err.println("No input file specified.");
System.exit(-1);
}
if (args.length > 1)
{
reader = new BufferedReader(new InputStreamReader(new FileInputStream(args[1]), "UTF-8"));
String line = reader.readLine();
while (line != null && !line.startsWith("<!-- ###"))
{
System.out.println(line);
line = reader.readLine();
}
}
System.out.println(Processor.process(new File(args[0])));
if (args.length > 1 && reader != null)
{
String line = reader.readLine();
while (line != null)
{
System.out.println(line);
line = reader.readLine();
}
reader.close();
}
} | java | {
"resource": ""
} |
q7573 | CmdLineParser.parse | train | public static List<String> parse(final String[] args, final Object... objs) throws IOException
{
final List<String> ret = Colls.list();
final List<Arg> allArgs = Colls.list();
final HashMap<String, Arg> shortArgs = new HashMap<String, Arg>();
final HashMap<String, Arg> longArgs = new HashMap<String, Arg>();
parseArgs(objs, allArgs, shortArgs, longArgs);
for (int i = 0; i < args.length; i++)
{
final String s = args[i];
final Arg a;
if (s.startsWith("--"))
{
a = longArgs.get(s.substring(2));
if (a == null)
{
throw new IOException("Unknown switch: " + s);
}
}
else if (s.startsWith("-"))
{
a = shortArgs.get(s.substring(1));
if (a == null)
{
throw new IOException("Unknown switch: " + s);
}
}
else
{
a = null;
ret.add(s);
}
if (a != null)
{
if (a.isSwitch)
{
a.setField("true");
}
else
{
if (i + 1 >= args.length)
{
System.out.println("Missing parameter for: " + s);
}
if (a.isCatchAll())
{
final List<String> ca = Colls.list();
for (++i; i < args.length; ++i)
{
ca.add(args[i]);
}
a.setCatchAll(ca);
}
else
{
++i;
a.setField(args[i]);
}
}
a.setPresent();
}
}
for (final Arg a : allArgs)
{
if (!a.isOk())
{
throw new IOException("Missing mandatory argument: " + a);
}
}
return ret;
} | java | {
"resource": ""
} |
q7574 | Utils.readUntil | train | public final static int readUntil(final StringBuilder out, final String in, final int start, final char end)
{
int pos = start;
while (pos < in.length())
{
final char ch = in.charAt(pos);
if (ch == '\\' && pos + 1 < in.length())
{
pos = escape(out, in.charAt(pos + 1), pos);
}
else
{
if (ch == end)
{
break;
}
out.append(ch);
}
pos++;
}
return (pos == in.length()) ? -1 : pos;
} | java | {
"resource": ""
} |
q7575 | Utils.readMdLink | train | public final static int readMdLink(final StringBuilder out, final String in, final int start)
{
int pos = start;
int counter = 1;
while (pos < in.length())
{
final char ch = in.charAt(pos);
if (ch == '\\' && pos + 1 < in.length())
{
pos = escape(out, in.charAt(pos + 1), pos);
}
else
{
boolean endReached = false;
switch (ch)
{
case '(':
counter++;
break;
case ' ':
if (counter == 1)
{
endReached = true;
}
break;
case ')':
counter--;
if (counter == 0)
{
endReached = true;
}
break;
}
if (endReached)
{
break;
}
out.append(ch);
}
pos++;
}
return (pos == in.length()) ? -1 : pos;
} | java | {
"resource": ""
} |
q7576 | Utils.readMdLinkId | train | public final static int readMdLinkId(final StringBuilder out, final String in, final int start)
{
int pos = start;
int counter = 1;
while (pos < in.length())
{
final char ch = in.charAt(pos);
boolean endReached = false;
switch (ch)
{
case '\n':
out.append(' ');
break;
case '[':
counter++;
out.append(ch);
break;
case ']':
counter--;
if (counter == 0)
{
endReached = true;
}
else
{
out.append(ch);
}
break;
default:
out.append(ch);
break;
}
if (endReached)
{
break;
}
pos++;
}
return (pos == in.length()) ? -1 : pos;
} | java | {
"resource": ""
} |
q7577 | Utils.readXMLUntil | train | public final static int readXMLUntil(final StringBuilder out, final String in, final int start, final char... end)
{
int pos = start;
boolean inString = false;
char stringChar = 0;
while (pos < in.length())
{
final char ch = in.charAt(pos);
if (inString)
{
if (ch == '\\')
{
out.append(ch);
pos++;
if (pos < in.length())
{
out.append(ch);
pos++;
}
continue;
}
if (ch == stringChar)
{
inString = false;
out.append(ch);
pos++;
continue;
}
}
switch (ch)
{
case '"':
case '\'':
inString = true;
stringChar = ch;
break;
}
if (!inString)
{
boolean endReached = false;
for (int n = 0; n < end.length; n++)
{
if (ch == end[n])
{
endReached = true;
break;
}
}
if (endReached)
{
break;
}
}
out.append(ch);
pos++;
}
return (pos == in.length()) ? -1 : pos;
} | java | {
"resource": ""
} |
q7578 | Utils.appendCode | train | public final static void appendCode(final StringBuilder out, final String in, final int start, final int end)
{
for (int i = start; i < end; i++)
{
final char c;
switch (c = in.charAt(i))
{
case '&':
out.append("&");
break;
case '<':
out.append("<");
break;
case '>':
out.append(">");
break;
default:
out.append(c);
break;
}
}
} | java | {
"resource": ""
} |
q7579 | Utils.appendDecEntity | train | public final static void appendDecEntity(final StringBuilder out, final char value)
{
out.append("&#");
out.append((int)value);
out.append(';');
} | java | {
"resource": ""
} |
q7580 | Utils.codeEncode | train | public final static void codeEncode(final StringBuilder out, final String value, final int offset)
{
for (int i = offset; i < value.length(); i++)
{
final char c = value.charAt(i);
switch (c)
{
case '&':
out.append("&");
break;
case '<':
out.append("<");
break;
case '>':
out.append(">");
break;
default:
out.append(c);
}
}
} | java | {
"resource": ""
} |
q7581 | Line.countCharsStart | train | private int countCharsStart(final char ch, final boolean allowSpaces)
{
int count = 0;
for (int i = 0; i < this.value.length(); i++)
{
final char c = this.value.charAt(i);
if (c == ' ' && allowSpaces)
{
continue;
}
if (c == ch)
{
count++;
}
else
{
break;
}
}
return count;
} | java | {
"resource": ""
} |
q7582 | SimplifySpanBuild.append | train | public SimplifySpanBuild append(String text) {
if (TextUtils.isEmpty(text)) return this;
mNormalSizeText.append(text);
mStringBuilder.append(text);
return this;
} | java | {
"resource": ""
} |
q7583 | SimplifySpanBuild.appendMultiClickable | train | public SimplifySpanBuild appendMultiClickable(SpecialClickableUnit specialClickableUnit, Object... specialUnitOrStrings) {
processMultiClickableSpecialUnit(false, specialClickableUnit, specialUnitOrStrings);
return this;
} | java | {
"resource": ""
} |
q7584 | HubProxy.Invoke | train | @Override
public void Invoke(final String method, JSONArray args,
HubInvokeCallback callback) {
if (method == null)
{
throw new IllegalArgumentException("method");
}
if (args == null)
{
throw new IllegalArgumentException("args");
}
final String callbackId = mConnection.RegisterCallback(callback);
HubInvocation hubData = new HubInvocation(mHubName, method, args, callbackId);
String value = hubData.Serialize();
mConnection.Send(value, new SendCallback()
{
@Override
public void OnSent(CharSequence messageSent) {
Log.v(TAG, "Invoke of " + method + "sent to " + mHubName);
// callback.OnSent() ??!?!?
}
@Override
public void OnError(Exception ex) {
// TODO Cancel the callback
Log.e(TAG, "Failed to invoke " + method + "on " + mHubName);
mConnection.RemoveCallback(callbackId);
// callback.OnError() ?!?!?
}
});
} | java | {
"resource": ""
} |
q7585 | LineColorResolver.resolveLineAlpha | train | @IntRange(from = 0, to = OPAQUE)
private static int resolveLineAlpha(
@IntRange(from = 0, to = OPAQUE) final int sceneAlpha,
final float maxDistance,
final float distance) {
final float alphaPercent = 1f - distance / maxDistance;
final int alpha = (int) ((float) OPAQUE * alphaPercent);
return alpha * sceneAlpha / OPAQUE;
} | java | {
"resource": ""
} |
q7586 | ParticleGenerator.applyFreshParticleOnScreen | train | void applyFreshParticleOnScreen(
@NonNull final Scene scene,
final int position
) {
final int w = scene.getWidth();
final int h = scene.getHeight();
if (w == 0 || h == 0) {
throw new IllegalStateException(
"Cannot generate particles if scene width or height is 0");
}
final double direction = Math.toRadians(random.nextInt(360));
final float dCos = (float) Math.cos(direction);
final float dSin = (float) Math.sin(direction);
final float x = random.nextInt(w);
final float y = random.nextInt(h);
final float speedFactor = newRandomIndividualParticleSpeedFactor();
final float radius = newRandomIndividualParticleRadius(scene);
scene.setParticleData(
position,
x,
y,
dCos,
dSin,
radius,
speedFactor);
} | java | {
"resource": ""
} |
q7587 | ParticleGenerator.applyFreshParticleOffScreen | train | void applyFreshParticleOffScreen(
@NonNull final Scene scene,
final int position) {
final int w = scene.getWidth();
final int h = scene.getHeight();
if (w == 0 || h == 0) {
throw new IllegalStateException(
"Cannot generate particles if scene width or height is 0");
}
float x = random.nextInt(w);
float y = random.nextInt(h);
// The offset to make when creating point of out bounds
final short offset = (short) (scene.getParticleRadiusMin() + scene.getLineLength());
// Point angle range
final float startAngle;
float endAngle;
// Make random offset and calulate angles so that the direction of travel will always be
// towards our View
switch (random.nextInt(4)) {
case 0:
// offset to left
x = (short) -offset;
startAngle = angleDeg(pcc, pcc, x, y);
endAngle = angleDeg(pcc, h - pcc, x, y);
break;
case 1:
// offset to top
y = (short) -offset;
startAngle = angleDeg(w - pcc, pcc, x, y);
endAngle = angleDeg(pcc, pcc, x, y);
break;
case 2:
// offset to right
x = (short) (w + offset);
startAngle = angleDeg(w - pcc, h - pcc, x, y);
endAngle = angleDeg(w - pcc, pcc, x, y);
break;
case 3:
// offset to bottom
y = (short) (h + offset);
startAngle = angleDeg(pcc, h - pcc, x, y);
endAngle = angleDeg(w - pcc, h - pcc, x, y);
break;
default:
throw new IllegalArgumentException("Supplied value out of range");
}
if (endAngle < startAngle) {
endAngle += 360;
}
// Get random angle from angle range
final float randomAngleInRange = startAngle + (random
.nextInt((int) Math.abs(endAngle - startAngle)));
final double direction = Math.toRadians(randomAngleInRange);
final float dCos = (float) Math.cos(direction);
final float dSin = (float) Math.sin(direction);
final float speedFactor = newRandomIndividualParticleSpeedFactor();
final float radius = newRandomIndividualParticleRadius(scene);
scene.setParticleData(
position,
x,
y,
dCos,
dSin,
radius,
speedFactor);
} | java | {
"resource": ""
} |
q7588 | ParticleGenerator.angleDeg | train | private static float angleDeg(final float ax, final float ay,
final float bx, final float by) {
final double angleRad = Math.atan2(ay - by, ax - bx);
double angle = Math.toDegrees(angleRad);
if (angleRad < 0) {
angle += 360;
}
return (float) angle;
} | java | {
"resource": ""
} |
q7589 | ParticleGenerator.newRandomIndividualParticleRadius | train | private float newRandomIndividualParticleRadius(@NonNull final SceneConfiguration scene) {
return scene.getParticleRadiusMin() == scene.getParticleRadiusMax() ?
scene.getParticleRadiusMin() : scene.getParticleRadiusMin() + (random.nextInt(
(int) ((scene.getParticleRadiusMax() - scene.getParticleRadiusMin()) * 100f)))
/ 100f;
} | java | {
"resource": ""
} |
q7590 | DistanceResolver.distance | train | public static float distance(final float ax, final float ay,
final float bx, final float by) {
return (float) Math.sqrt(
(ax - bx) * (ax - bx) +
(ay - by) * (ay - by)
);
} | java | {
"resource": ""
} |
q7591 | BasicPasswordCredentials.toGrgit | train | public Credentials toGrgit() {
if (username != null && password != null) {
return new Credentials(username, password);
} else {
return null;
}
} | java | {
"resource": ""
} |
q7592 | MainActivity.onSampleActivityCTAClick | train | @OnClick(R.id.navigateToSampleActivity)
public void onSampleActivityCTAClick() {
StringParcel parcel1 = new StringParcel("Andy");
StringParcel parcel2 = new StringParcel("Tony");
List<StringParcel> parcelList = new ArrayList<>();
parcelList.add(parcel1);
parcelList.add(parcel2);
SparseArray<StringParcel> parcelSparseArray = new SparseArray<>();
parcelSparseArray.put(0, parcel1);
parcelSparseArray.put(2, parcel2);
Intent intent = HensonNavigator.gotoSampleActivity(this)
.defaultKeyExtra("defaultKeyExtra")
.extraInt(4)
.extraListParcelable(parcelList)
.extraParcel(parcel1)
.extraParcelable(ComplexParcelable.random())
.extraSparseArrayParcelable(parcelSparseArray)
.extraString("a string")
.build();
startActivity(intent);
} | java | {
"resource": ""
} |
q7593 | MainActivity.onNavigationServiceCTAClick | train | @OnClick(R.id.navigateToModule1Service)
public void onNavigationServiceCTAClick() {
Intent intentService = HensonNavigator.gotoModule1Service(this)
.stringExtra("foo")
.build();
startService(intentService);
} | java | {
"resource": ""
} |
q7594 | StringUtil.isValidFqcn | train | public static boolean isValidFqcn(String str) {
if (isNullOrEmpty(str)) {
return false;
}
final String[] parts = str.split("\\.");
if (parts.length < 2) {
return false;
}
for (String part : parts) {
if (!isValidJavaIdentifier(part)) {
return false;
}
}
return true;
} | java | {
"resource": ""
} |
q7595 | TaskManager.createHensonNavigatorGenerationTask | train | public TaskProvider<GenerateHensonNavigatorTask> createHensonNavigatorGenerationTask(
BaseVariant variant, String hensonNavigatorPackageName, File destinationFolder) {
TaskProvider<GenerateHensonNavigatorTask> generateHensonNavigatorTask =
project
.getTasks()
.register(
"generate" + capitalize(variant.getName()) + "HensonNavigator",
GenerateHensonNavigatorTask.class,
(Action<GenerateHensonNavigatorTask>)
generateHensonNavigatorTask1 -> {
generateHensonNavigatorTask1.hensonNavigatorPackageName =
hensonNavigatorPackageName;
generateHensonNavigatorTask1.destinationFolder = destinationFolder;
generateHensonNavigatorTask1.variant = variant;
generateHensonNavigatorTask1.logger = logger;
generateHensonNavigatorTask1.project = project;
generateHensonNavigatorTask1.hensonNavigatorGenerator =
hensonNavigatorGenerator;
});
return generateHensonNavigatorTask;
} | java | {
"resource": ""
} |
q7596 | Bundler.put | train | public Bundler put(String key, Bundle value) {
delegate.putBundle(key, value);
return this;
} | java | {
"resource": ""
} |
q7597 | Bundler.put | train | public Bundler put(String key, String value) {
delegate.putString(key, value);
return this;
} | java | {
"resource": ""
} |
q7598 | Bundler.put | train | public Bundler put(String key, String[] value) {
delegate.putStringArray(key, value);
return this;
} | java | {
"resource": ""
} |
q7599 | Bundler.put | train | public Bundler put(String key, CharSequence value) {
delegate.putCharSequence(key, value);
return this;
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.