Send a {@link #Constants.WARN} log message and log the exception.

@param tr
An exception to log
508179
public static int w(String tag, Throwable tr) {
        collectLogEntry(Constants.WARN, tag, "", null);
        if (isLoggable(tag, Constants.WARN)) {
            return android.util.Log.w(tag, tr);
        }
        return 0;
    }
806748
@Deprecated
  public void warn(String message, Throwable t)
  {
    log.warn(message, t);
  }
1115910
public void warn( String msg, Throwable t )
    {
        if( m_delegate.isWarnEnabled() )
        {
            m_delegate.warn( msg, t );
        }
    }
1080269
@Override
	public void warn(String msg, Throwable e) {
		LoggerFactory.getLogger(from).warn(msg);
	}
586550
public void warn(String msg, ServiceReference sr) {
        doLog(msg, LOG_WARNING, sr, null );
    }
577112
public static int wtf(String tag, Throwable tr) {
        return wtf(LOG_ID_MAIN, tag, tr.getMessage(), tr, false);
    }
451231
public void warn(Object message, Throwable t)
    {
        getLogger().warn(message.toString(), t);
    }
1201084
public void warn(String s) {
        if (isEnabled() && isWarnEnabled()) {
            dispatchLogMessage(new LogEvent(this, LogEvent.WARN_TYPE, s));
        }
    }
254328
public final void fatal(Object message, Throwable t) {

        if (isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL)) {
            log(SimpleLog.LOG_LEVEL_FATAL, message, t);
        }
    }
1360162
private void sendMessageToLogger(Level level, String message, Log log, Throwable e) {

        if (e == null) {
            if (level == Level.SEVERE) {
                log.error(message);
            } else if (level == Level.WARNING) {
                log.warn(message);
            } else if (level == Level.INFO) {
                log.info(message);
            } else if (level == Level.CONFIG) {
                log.info(message);
            } else if ((level == Level.FINE) || (level == Level.FINER) || (level == Level.FINEST)) {
                log.debug(message);
            } else {
                log.info(message);
            }
        } else {
            if (level == Level.SEVERE) {
                log.error(message, e);
            } else if (level == Level.WARNING) {
                log.warn(message, e);
            } else if (level == Level.INFO) {
                log.info(message, e);
            } else if (level == Level.CONFIG) {
                log.info(message, e);
            } else if ((level == Level.FINE) || (level == Level.FINER) || (level == Level.FINEST)) {
                log.debug(message, e);
            } else {
                log.info(message, e);
            }
        }
    }
453290
public void warn(Throwable t) {
        if (isEnabled() && isWarnEnabled()) {
            dispatchLogException(new LogEvent(this, LogEvent.WARN_TYPE, t));
        }
    }
729555
private void println(int logLevel, String msg, Throwable tr) {
    if (logLevel < logConfiguration.logLevel) {
      return;
    }
    printlnInternal(logLevel, ((msg == null || msg.length() == 0)
        ? "" : (msg + SystemCompat.lineSeparator))
        + logConfiguration.throwableFormatter.format(tr));
  }
1241803
public void setException(Throwable t) {
    if (err == null) {
      t.printStackTrace();
    } else {
      err.emit(t);
    }
  }
867359
private static void  warn(String format, Object... args)
   {
      Log.w(TAG, String.format(format, args));
   }
721500
public static void warn(final Object message, final Throwable t) {
        warnStream.println(APP_WARN + message.toString());
        warnStream.println(stackTraceToString(t));
    }
1226554
public static void warnWithException(Logger logger, String format, Object... arguments) {
    if (logger.isDebugEnabled()) {
      logger.warn(format, arguments);
    } else {
      Object last = arguments[arguments.length - 1];
      if (last instanceof Throwable) {
        Throwable t = (Throwable) last;
        arguments[arguments.length - 1] = t.getClass().getSimpleName() + ": " + t.getMessage();
        logger.warn(format + " ({})", arguments);
      } else {
        // Should only be called with an exception as last argument, but handle gracefully anyway
        logger.warn(format, arguments);
      }
    }
  }
208517
public static void sendCurrentWarning(Object source, Throwable e)
  {
    WarningSystem warning = getCurrent();
    
    if (warning != null)
      warning.sendWarning(source, e);
    else {
      e.printStackTrace();
      log.log(Level.WARNING, e.toString(), e);
    }
  }