Java Logger.getLogger方法代码示例

import org.jitsi.util.Logger; //导入方法依赖的package包/类
/**
 * Initializes a new <tt>RawUdpTransportManager</tt> instance.
 *
 * @param channel the <tt>Channel</tt> which is initializing the new
 * instance
 */
public RawUdpTransportManager(Channel channel)
    throws IOException
{
    super();

    this.channel = channel;
    this.logger
        = Logger.getLogger(
                classLogger,
                channel.getContent().getConference().getLogger());
    addChannel(channel);

    streamConnector = createStreamConnector();
    /*
     * Each candidate harvest modifies the generation and the IDs of the RTP
     * and RTCP candidates.
     */
    generation = 0;
    rtpCandidateID = generateCandidateID();
    rtcpCandidateID = generateCandidateID();
}
 

import org.jitsi.util.Logger; //导入方法依赖的package包/类
/**
 * Creates new {@link JibriSession} instance.
 * @param owner the session owner which will be notified about this session
 * state changes.
 * @param roomName the name if the XMPP MUC room (full address).
 * @param pendingTimeout how many seconds this session can wait in pending
 * state, before trying another Jibri instance or failing with an error.
 * @param connection the XMPP connection which will be used to send/listen
 * for packets.
 * @param scheduledExecutor the executor service which will be used to
 * schedule pending timeout task execution.
 * @param jibriDetector the Jibri detector which will be used to select
 * Jibri instance.
 * @param isSIP <tt>true</tt> if it's a SIP session or <tt>false</tt> for
 * a regular live streaming Jibri type of session.
 * @param sipAddress a SIP address if it's a SIP session
 * @param displayName a display name to be used by Jibri participant
 * entering the conference once the session starts.
 * @param streamID a live streaming ID if it's not a SIP session
 * @param logLevelDelegate logging level delegate which will be used to
 * select logging level for this instance {@link #logger}.
 */
public JibriSession(
        JibriSession.Owner          owner,
        EntityBareJid               roomName,
        long                        pendingTimeout,
        XmppConnection              connection,
        ScheduledExecutorService    scheduledExecutor,
        JibriDetector               jibriDetector,
        boolean                     isSIP,
        String                      sipAddress,
        String                      displayName,
        String                      streamID,
        Logger                      logLevelDelegate)
{
    this.owner = owner;
    this.roomName = roomName;
    this.scheduledExecutor
        = Objects.requireNonNull(scheduledExecutor, "scheduledExecutor");
    this.pendingTimeout = pendingTimeout;
    this.isSIP = isSIP;
    this.jibriDetector = jibriDetector;
    this.sipAddress = sipAddress;
    this.displayName = displayName;
    this.streamID = streamID;
    this.xmpp = connection;
    logger = Logger.getLogger(classLogger, logLevelDelegate);
}
 

import org.jitsi.util.Logger; //导入方法依赖的package包/类
public ChatRoomRoleAndPresence(JitsiMeetConferenceImpl conference,
                               ChatRoom chatRoom)
{
    this.conference = Objects.requireNonNull(conference, "conference");
    this.chatRoom = Objects.requireNonNull(chatRoom, "chatRoom");

    this.logger = Logger.getLogger(classLogger, conference.getLogger());
}
 

import org.jitsi.util.Logger; //导入方法依赖的package包/类
/**
 * Initializes a new <tt>SctpConnection</tt> instance.
 *
 * @param id the string identifier of this connection instance
 * @param content the <tt>Content</tt> which is initializing the new
 * instance
 * @param endpoint the <tt>Endpoint</tt> of newly created instance
 * @param remoteSctpPort the SCTP port used by remote peer
 * @param channelBundleId the ID of the channel-bundle this
 * <tt>SctpConnection</tt> is to be a part of (or <tt>null</tt> if no it is
 * not to be a part of a channel-bundle).
 * @throws Exception if an error occurs while initializing the new instance
 */
public SctpConnection(
        String id,
        Content content,
        Endpoint endpoint,
        int remoteSctpPort,
        String channelBundleId,
        Boolean initiator)
    throws Exception
{
    super(
            content,
            id,
            channelBundleId,
            IceUdpTransportPacketExtension.NAMESPACE,
            initiator);

    logger
        = Logger.getLogger(classLogger, content.getConference().getLogger());
    setEndpoint(endpoint);
    packetQueue
        = new RawPacketQueue(
            false,
            getClass().getSimpleName() + "-" + endpoint.getID(),
            handler);

    this.remoteSctpPort = remoteSctpPort;
    this.debugId = generateDebugId();
}
 

import org.jitsi.util.Logger; //导入方法依赖的package包/类
/**
 * Initializes a new <tt>IceUdpTransportManager</tt> instance.
 *
 * @param conference the <tt>Conference</tt> which created this
 * <tt>TransportManager</tt>.
 * @param controlling {@code true} if the new instance is to serve as a
 * controlling ICE agent and passive DTLS endpoint; otherwise, {@code false}
 * @param numComponents the number of ICE components that this instance is
 * to start with.
 * @param iceStreamName the name of the ICE stream to be created by this
 * instance.
 * @param id an identifier of the {@link IceUdpTransportManager}.
 * @throws IOException
 */
public IceUdpTransportManager(Conference conference,
                              boolean controlling,
                              int numComponents,
                              String iceStreamName,
                              String id)
    throws IOException
{
    this.conference = conference;
    this.id = id;
    this.controlling = controlling;
    this.numComponents = numComponents;
    this.rtcpmux = numComponents == 1;
    this.logger = Logger.getLogger(classLogger, conference.getLogger());
    this.transportCCEngine = new TransportCCEngine(diagnosticContext);

    // Setup the diagnostic context.
    conference.appendDiagnosticInformation(diagnosticContext);
    diagnosticContext.put("transport", hashCode());

    dtlsControl = createDtlsControl();

    iceAgent = createIceAgent(controlling, iceStreamName, rtcpmux);
    iceAgent.addStateChangeListener(iceAgentStateChangeListener);
    iceStream = iceAgent.getStream(iceStreamName);
    iceStream.addPairChangeListener(iceStreamPairChangeListener);

    EventAdmin eventAdmin = conference.getEventAdmin();
    if (eventAdmin != null)
    {
        eventAdmin.sendEvent(EventFactory.transportCreated(this));
    }
}
 

import org.jitsi.util.Logger; //导入方法依赖的package包/类
/**
 * Initializes a new <tt>VideoChannel</tt> instance which is to have a
 * specific ID. The initialization is to be considered requested by a
 * specific <tt>Content</tt>.
 *
 * @param content the <tt>Content</tt> which is initializing the new
 * instance
 * @param id the ID of the new instance. It is expected to be unique within
 * the list of <tt>Channel</tt>s listed in <tt>content</tt> while the new
 * instance is listed there as well.
 * @param channelBundleId the ID of the channel-bundle this
 * <tt>VideoChannel</tt> is to be a part of (or <tt>null</tt> if no it is
 * not to be a part of a channel-bundle).
 * @param transportNamespace the namespace of transport used by this
 * channel. Can be either {@link IceUdpTransportPacketExtension#NAMESPACE}
 * or {@link RawUdpTransportPacketExtension#NAMESPACE}.
 * @param initiator the value to use for the initiator field, or
 * <tt>null</tt> to use the default value.
 * @throws Exception if an error occurs while initializing the new instance
 */
VideoChannel(Content content,
             String id,
             String channelBundleId,
             String transportNamespace,
             Boolean initiator)
    throws Exception
{
    super(content, id, channelBundleId, transportNamespace, initiator);

    logger
        = Logger.getLogger(
                classLogger,
                content.getConference().getLogger());

    this.lipSyncHack
        = cfg != null && cfg.getBoolean(ENABLE_LIPSYNC_HACK_PNAME, true)
        ? new LipSyncHack(this) : null;

    disableLastNNotifications = cfg != null
        && cfg.getBoolean(DISABLE_LASTN_NOTIFICATIONS_PNAME, false);

    initializeTransformerEngine();

    if (cfg != null && cfg.getBoolean(LOG_OVERSENDING_STATS_PNAME, false))
    {
        logOversendingStatsRunnable = createLogOversendingStatsRunnable();
        getRecurringExecutor().registerRecurringRunnable(
            logOversendingStatsRunnable);
    }
    else
    {
        logOversendingStatsRunnable = null;
    }

    getRecurringExecutor().registerRecurringRunnable(bandwidthProbing);
}
 

import org.jitsi.util.Logger; //导入方法依赖的package包/类
/**
 * Initializes a new <tt>Channel</tt> instance which is to have a specific
 * ID. The initialization is to be considered requested by a specific
 * <tt>Content</tt>.
 *
 * @param content the <tt>Content</tt> which is initializing the new
 * instance
 * @param id the ID of the new instance. It is expected to be unique within
 * the list of <tt>Channel</tt>s listed in <tt>content</tt> while the new
 * instance is listed there as well.
 * @param channelBundleId the ID of the channel-bundle this
 * <tt>RtpChannel</tt> is to be a part of (or <tt>null</tt> if no it is
 * not to be a part of a channel-bundle).
 * @param transportNamespace the namespace of the transport to be used by
 * the new instance. Can be either
 * {@link IceUdpTransportPacketExtension#NAMESPACE} or
 * {@link RawUdpTransportPacketExtension#NAMESPACE}.
 * @param initiator the value to use for the initiator field, or
 * <tt>null</tt> to use the default value.
 * @throws Exception if an error occurs while initializing the new instance
 */
public RtpChannel(
        Content content,
        String id,
        String channelBundleId,
        String transportNamespace,
        Boolean initiator)
    throws Exception
{
    super(content, id, channelBundleId, transportNamespace, initiator);

    logger
        = Logger.getLogger(
                classLogger,
                content.getConference().getLogger());

    /*
     * In the case of content mixing, each Channel has its own local
     * synchronization source identifier (SSRC), which Jitsi Videobridge
     * pre-announces.
     */
    initialLocalSSRC = Videobridge.RANDOM.nextLong() & 0xffffffffL;

    Conference conference = content.getConference();
    conference.addPropertyChangeListener(propertyChangeListener);

    conferenceSpeechActivity = conference.getSpeechActivity();
    if (conferenceSpeechActivity != null)
    {
        /*
         * The PropertyChangeListener will weakly reference this instance
         * and will unregister itself from the conference sooner or later.
         */
         conferenceSpeechActivity.addPropertyChangeListener(
                 propertyChangeListener);
    }

    content.addPropertyChangeListener(propertyChangeListener);

    if (IceUdpTransportPacketExtension.NAMESPACE.equals(
                    this.transportNamespace))
    {
        this.verifyRemoteAddress = false;
    }

    touch();
}