Java FLog.w方法代碼示例

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
public String getDebugServerHost() {
  // Check host setting first. If empty try to detect emulator type and use default
  // hostname for those
  String hostFromSettings = mPreferences.getString(PREFS_DEBUG_SERVER_HOST_KEY, null);

  if (!TextUtils.isEmpty(hostFromSettings)) {
    return Assertions.assertNotNull(hostFromSettings);
  }

  String host = AndroidInfoHelpers.getServerHost();

  if (host.equals(AndroidInfoHelpers.DEVICE_LOCALHOST)) {
    FLog.w(
      TAG,
      "You seem to be running on device. Run 'adb reverse tcp:8081 tcp:8081' " +
        "to forward the debug server's port to the device.");
  }

  return host;
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
@Override
protected void finalize() throws Throwable {
  try {
    // We put synchronized here so that lint doesn't warn about accessing mIsClosed, which is
    // guarded by this. Lint isn't aware of finalize semantics.
    synchronized (this) {
      if (mIsClosed) {
        return;
      }
    }

    FLog.w(
        TAG,
        "Finalized without closing: %x %x (type = %s)",
        System.identityHashCode(this),
        System.identityHashCode(mSharedReference),
        mSharedReference.get().getClass().getSimpleName());

    close();
  } finally {
    super.finalize();
  }
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
@Override
public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args) throws Throwable {
  ExecutorToken executorToken = mExecutorToken.get();
  if (executorToken == null) {
    FLog.w(ReactConstants.TAG, "Dropping JS call, ExecutorToken went away...");
    return null;
  }
  NativeArray jsArgs = args != null ? Arguments.fromJavaArgs(args) : new WritableNativeArray();
  mCatalystInstance.callFunction(
    executorToken,
    mModuleRegistration.getName(),
    method.getName(),
    jsArgs
  );
  return null;
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
/**
 * Parse a DebugServerException from the server json string.
 * @param str json string returned by the debug server
 * @return A DebugServerException or null if the string is not of proper form.
 */
@Nullable public static DebugServerException parse(String str) {
  if (TextUtils.isEmpty(str)) {
    return null;
  }
  try {
    JSONObject jsonObject = new JSONObject(str);
    String fullFileName = jsonObject.getString("filename");
    return new DebugServerException(
        jsonObject.getString("description"),
        shortenFileName(fullFileName),
        jsonObject.getInt("lineNumber"),
        jsonObject.getInt("column"));
  } catch (JSONException e) {
    // I'm not sure how strict this format is for returned errors, or what other errors there can
    // be, so this may end up being spammy. Can remove it later if necessary.
    FLog.w(ReactConstants.TAG, "Could not parse DebugServerException from: " + str, e);
    return null;
  }
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
/**
 * Determine if an valid entry for the key exists in the staging area.
 */
public synchronized boolean containsKey(CacheKey key) {
  Preconditions.checkNotNull(key);
  if (!mMap.containsKey(key)) {
    return false;
  }
  EncodedImage storedEncodedImage = mMap.get(key);
  synchronized (storedEncodedImage) {
    if (!EncodedImage.isValid(storedEncodedImage)) {
      // Reference is not valid, this means that someone cleared reference while it was still in
      // use. Log error
      // TODO: 3697790
      mMap.remove(key);
      FLog.w(
          TAG,
          "Found closed reference %d for key %s (%d)",
          System.identityHashCode(storedEncodedImage),
          key.getUriString(),
          System.identityHashCode(key));
      return false;
    }
    return true;
  }
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
private Task<Boolean> containsAsync(final CacheKey key) {
  try {
    return Task.call(
        new Callable<Boolean>() {
          @Override
          public Boolean call() throws Exception {
            return checkInStagingAreaAndFileCache(key);
          }
        },
        mReadExecutor);
  } catch (Exception exception) {
    // Log failure
    // TODO: 3697790
    FLog.w(
        TAG,
        exception,
        "Failed to schedule disk-cache read for %s",
        key.getUriString());
    return Task.forError(exception);
  }
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
private void dispatchCancelEvent(MotionEvent androidEvent, EventDispatcher eventDispatcher) {
  // This means the gesture has already ended, via some other CANCEL or UP event. This is not
  // expected to happen very often as it would mean some child View has decided to intercept the
  // touch stream and start a native gesture only upon receiving the UP/CANCEL event.
  if (mTargetTag == -1) {
    FLog.w(
      ReactConstants.TAG,
      "Can't cancel already finished gesture. Is a child View trying to start a gesture from " +
        "an UP/CANCEL event?");
    return;
  }

  Assertions.assertCondition(
    !mChildIsHandlingNativeGesture,
    "Expected to not have already sent a cancel for this gesture");
  Assertions.assertNotNull(eventDispatcher).dispatchEvent(
    TouchEvent.obtain(
      mTargetTag,
      TouchEventType.CANCEL,
      androidEvent,
      mGestureStartTime,
      mTargetCoordinates[0],
      mTargetCoordinates[1],
      mTouchEventCoalescingKeyHelper));
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
/**
 * Clears the disk cache and the staging area.
 */
public Task<Void> clearAll() {
  mStagingArea.clearAll();
  try {
    return Task.call(
        new Callable<Void>() {
          @Override
          public Void call() throws Exception {
            mStagingArea.clearAll();
            mFileCache.clearAll();
            return null;
          }
        },
        mWriteExecutor);
  } catch (Exception exception) {
    // Log failure
    // TODO: 3697790
    FLog.w(TAG, exception, "Failed to schedule disk-cache clear");
    return Task.forError(exception);
  }
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
/**
 * Writes to disk cache
 * @throws IOException
 */
private void writeToDiskCache(
    final CacheKey key,
    final EncodedImage encodedImage) {
  FLog.v(TAG, "About to write to disk-cache for key %s", key.getUriString());
  try {
    mFileCache.insert(
        key, new WriterCallback() {
          @Override
          public void write(OutputStream os) throws IOException {
            mPooledByteStreams.copy(encodedImage.getInputStream(), os);
          }
        }
    );
    FLog.v(TAG, "Successful disk-cache write for key %s", key.getUriString());
  } catch (IOException ioe) {
    // Log failure
    // TODO: 3697790
    FLog.w(TAG, ioe, "Failed to write to disk-cache for key %s", key.getUriString());
  }
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
private void reconnect() {
  if (mClosed) {
    throw new IllegalStateException("Can't reconnect closed client");
  }
  if (!mSuppressConnectionErrors) {
    FLog.w(TAG, "Couldn't connect to packager, will silently retry");
    mSuppressConnectionErrors = true;
  }
  mHandler.postDelayed(
      new Runnable() {
        @Override
        public void run() {
          // check that we haven't been closed in the meantime
          if (!mClosed) {
            connect();
          }
        }
      },
      RECONNECT_DELAY_MS);
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
public int resolveRootTagFromReactTag(int reactTag) {
  if (mShadowNodeRegistry.isRootNode(reactTag)) {
    return reactTag;
  }

  ReactShadowNode node = resolveShadowNode(reactTag);
  int rootTag = 0;
  if (node != null) {
    rootTag = node.getRootNode().getReactTag();
  } else {
    FLog.w(
      ReactConstants.TAG,
      "Warning : attempted to resolve a non-existent react shadow node. reactTag=" + reactTag);
  }

  return rootTag;
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
@ReactMethod
public void notifyTaskFinished(int taskId) {
  HeadlessJsTaskContext headlessJsTaskContext =
    HeadlessJsTaskContext.getInstance(getReactApplicationContext());
  if (headlessJsTaskContext.isTaskRunning(taskId)) {
    headlessJsTaskContext.finishTask(taskId);
  } else {
    FLog.w(
      HeadlessJsTaskSupportModule.class,
      "Tried to finish non-active task with id %d. Did it time out?",
      taskId);
  }
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
@Override
protected void onCancelled(Result<ReactApplicationContext> reactApplicationContextResult) {
  try {
    mMemoryPressureRouter.destroy(reactApplicationContextResult.get());
  } catch (Exception e) {
    FLog.w(ReactConstants.TAG, "Caught exception after cancelling react context init", e);
  } finally {
    mReactContextInitAsyncTask = null;
  }
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
@Override
public void onChildStartedNativeGesture(MotionEvent androidEvent) {
  if (mReactInstanceManager == null || !mIsAttachedToInstance ||
    mReactInstanceManager.getCurrentReactContext() == null) {
    FLog.w(
      ReactConstants.TAG,
      "Unable to dispatch touch to JS as the catalyst instance has not been attached");
    return;
  }
  ReactContext reactContext = mReactInstanceManager.getCurrentReactContext();
  EventDispatcher eventDispatcher = reactContext.getNativeModule(UIManagerModule.class)
    .getEventDispatcher();
  mJSTouchDispatcher.onChildStartedNativeGesture(androidEvent, eventDispatcher);
}
 

import com.facebook.common.logging.FLog; //導入方法依賴的package包/類
@Override
public void invokeCallback(ExecutorToken executorToken, final int callbackID, final NativeArray arguments) {
  if (mDestroyed) {
    FLog.w(ReactConstants.TAG, "Invoking JS callback after bridge has been destroyed.");
    return;
  }

  jniCallJSCallback(executorToken, callbackID, arguments);
}