Java Logger.log方法代码示例

import com.facebook.internal.Logger; //导入方法依赖的package包/类
@Override
protected void processError(FacebookRequestError error) {
    int errorCode = error.getErrorCode();
    if (errorCode == ERROR_CODE_OBJECT_ALREADY_LIKED) {
        // This isn't an error for us. Client was just out of sync with server
        // This will prevent us from showing the dialog for this.

        // However, there is no unliketoken. So a subsequent unlike WILL show the dialog
        this.error = null;
    } else {
        Logger.log(LoggingBehavior.REQUESTS,
                TAG,
                "Error liking object '%s' with type '%s' : %s",
                objectId,
                objectType,
                error);
        logAppEventForError("publish_like", error);
    }
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
/**
 * Persists all supported data types present in the passed in Bundle, to the
 * cache
 *
 * @param bundle
 *          The Bundle containing information to be cached
 */
public void save(Bundle bundle) {
    Validate.notNull(bundle, "bundle");

    SharedPreferences.Editor editor = cache.edit();

    for (String key : bundle.keySet()) {
        try {
            serializeKey(key, bundle, editor);
        } catch (JSONException e) {
            // Error in the bundle. Don't store a partial cache.
            Logger.log(LoggingBehavior.CACHE, Log.WARN, TAG, "Error processing value for key: '" + key + "' -- " + e);

            // Bypass the commit and just return. This cancels the entire edit transaction
            return;
        }
    }

    boolean successfulCommit = editor.commit();
    if (!successfulCommit) {
        Logger.log(LoggingBehavior.CACHE, Log.WARN, TAG, "SharedPreferences.Editor.commit() was not successful");
    }
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
/**
 * Returns a Bundle that contains the information stored in this cache
 *
 * @return A Bundle with the information contained in this cache
 */
public Bundle load() {
    Bundle settings = new Bundle();

    Map<String, ?> allCachedEntries = cache.getAll();

    for (String key : allCachedEntries.keySet()) {
        try {
            deserializeKey(key, settings);
        } catch (JSONException e) {
            // Error in the cache. So consider it corrupted and return null
            Logger.log(LoggingBehavior.CACHE, Log.WARN, TAG,
                    "Error reading cached value for key: '" + key + "' -- " + e);
            return null;
        }
    }

    return settings;
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
static List<GraphResponse> createResponsesFromString(
        String responseString,
        HttpURLConnection connection,
        GraphRequestBatch requests
) throws FacebookException, JSONException, IOException {
    JSONTokener tokener = new JSONTokener(responseString);
    Object resultObject = tokener.nextValue();

    List<GraphResponse> responses = createResponsesFromObject(
            connection,
            requests,
            resultObject);
    Logger.log(
            LoggingBehavior.REQUESTS,
            RESPONSE_LOG_TAG,
            "Response\n  Id: %s\n  Size: %d\n  Responses:\n%s\n",
            requests.getId(),
            responseString.length(),
            responses);

    return responses;
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
public Bundle load() {
    Bundle settings = new Bundle();

    Map<String, ?> allCachedEntries = cache.getAll();

    for (String key : allCachedEntries.keySet()) {
        try {
            deserializeKey(key, settings);
        } catch (JSONException e) {
            // Error in the cache. So consider it corrupted and return null
            Logger.log(LoggingBehavior.CACHE, Log.WARN, TAG,
                    "Error reading cached value for key: '" + key + "' -- " + e);
            return null;
        }
    }

    return settings;
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
public void save(Bundle bundle) {
    Validate.notNull(bundle, "bundle");

    SharedPreferences.Editor editor = cache.edit();

    for (String key : bundle.keySet()) {
        try {
            serializeKey(key, bundle, editor);
        } catch (JSONException e) {
            // Error in the bundle. Don't store a partial cache.
            Logger.log(
                    LoggingBehavior.CACHE,
                    Log.WARN,
                    TAG,
                    "Error processing value for key: '" + key + "' -- " + e);

            // Bypass the commit and just return. This cancels the entire edit transaction
            return;
        }
    }
    editor.apply();
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
/**
 * Persists all supported data types present in the passed in Bundle, to the
 * cache
 *
 * @param bundle
 *          The Bundle containing information to be cached
 */
public void save(Bundle bundle) {
    Validate.notNull(bundle, "bundle");

    SharedPreferences.Editor editor = cache.edit();

    for (String key : bundle.keySet()) {
        try {
            serializeKey(key, bundle, editor);
        } catch (JSONException e) {
            // Error in the bundle. Don't store a partial cache.
            Logger.log(LoggingBehavior.CACHE, Log.WARN, TAG, "Error processing value for key: '" + key + "' -- " + e);

            // Bypass the commit and just return. This cancels the entire edit transaction
            return;
        }
    }
    editor.apply();
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
void onSuspend(AppEventsLogger logger, long eventTime) {
    if (!isAppActive) {
        Logger.log(LoggingBehavior.APP_EVENTS, TAG, "Suspend for inactive app");
        return;
    }

    long now = eventTime;
    long delta = (now - lastResumeTime);
    if (delta < 0) {
        Logger.log(LoggingBehavior.APP_EVENTS, TAG, "Clock skew detected");
        delta = 0;
    }
    millisecondsSpentInSession += delta;
    lastSuspendTime = now;
    isAppActive = false;
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
private void processResponse(ImageResponse response) {
    // First check if the response is for the right request. We may have:
    // 1. Sent a new request, thus super-ceding this one.
    // 2. Detached this view, in which case the response should be discarded.
    if (response.getRequest() == lastRequest) {
        lastRequest = null;
        Bitmap responseImage = response.getBitmap();
        Exception error = response.getError();
        if (error != null) {
            OnErrorListener listener = onErrorListener;
            if (listener != null) {
                listener.onError(new FacebookException(
                        "Error in downloading profile picture for profileId: " + getProfileId(), error));
            } else {
                Logger.log(LoggingBehavior.REQUESTS, Log.ERROR, TAG, error.toString());
            }
        } else if (responseImage != null) {
            setImageBitmap(responseImage);

            if (response.isCachedRedirect()) {
                sendImageRequest(false);
            }
        }
    }
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
static List<GraphResponse> createResponsesFromStream(
        InputStream stream,
        HttpURLConnection connection,
        GraphRequestBatch requests
) throws FacebookException, JSONException, IOException {

    String responseString = Utility.readStreamToString(stream);
    Logger.log(LoggingBehavior.INCLUDE_RAW_RESPONSES, RESPONSE_LOG_TAG,
            "Response (raw)\n  Size: %d\n  Response:\n%s\n", responseString.length(),
            responseString);

    return createResponsesFromString(responseString, connection, requests);
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
/**
 * Deprecated. Please use {@link AppEventsLogger} instead.
 */
public void logConversionPixel(String pixelId, double valueOfPixel) {

    if (pixelId == null) {
        Logger.log(LoggingBehavior.DEVELOPER_ERRORS, "Insights", "pixelID cannot be null");
        return;
    }

    Bundle parameters = new Bundle();
    parameters.putString(EVENT_PARAMETER_PIXEL_ID, pixelId);
    parameters.putDouble(EVENT_PARAMETER_PIXEL_VALUE, valueOfPixel);

    appEventsLogger.logEvent(EVENT_NAME_LOG_CONVERSION_PIXEL, valueOfPixel, parameters);
    AppEventsLogger.eagerFlush();
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
static List<Response> createResponsesFromStream(InputStream stream, HttpURLConnection connection,
        RequestBatch requests, boolean isFromCache) throws FacebookException, JSONException, IOException {

    String responseString = Utility.readStreamToString(stream);
    Logger.log(LoggingBehavior.INCLUDE_RAW_RESPONSES, RESPONSE_LOG_TAG,
            "Response (raw)\n  Size: %d\n  Response:\n%s\n", responseString.length(),
            responseString);

    return createResponsesFromString(responseString, connection, requests, isFromCache);
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
@Override
protected void processError(FacebookRequestError error) {
    Logger.log(LoggingBehavior.REQUESTS,
            TAG,
            "Error getting the FB id for object '%s' with type '%s' : %s",
            objectId,
            objectType,
            error);
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private static void restoreAppSessionInformation(Context context) {
    ObjectInputStream ois = null;

    synchronized (staticLock) {
        if (!isLoaded) {
            try {
                ois =
                        new ObjectInputStream(
                                context.openFileInput(PERSISTED_SESSION_INFO_FILENAME));
                appSessionInfoMap =
                        (HashMap<AccessTokenAppIdPair, FacebookTimeSpentData>) ois.readObject();
                Logger.log(
                        LoggingBehavior.APP_EVENTS,
                        "AppEvents",
                        "App session info loaded");
            } catch (FileNotFoundException fex) {
            } catch (Exception e) {
                Log.d(TAG, "Got unexpected exception: " + e.toString());
            } finally {
                Utility.closeQuietly(ois);
                context.deleteFile(PERSISTED_SESSION_INFO_FILENAME);
                if (appSessionInfoMap == null) {
                    appSessionInfoMap =
                            new HashMap<AccessTokenAppIdPair, FacebookTimeSpentData>();
                }
                // Regardless of the outcome of the load, the session information cache
                // is always deleted. Therefore, always treat the session information cache
                // as loaded
                isLoaded = true;
                hasChanges = false;
            }
        }
    }
}
 

import com.facebook.internal.Logger; //导入方法依赖的package包/类
private static void handleResponse(
        AccessTokenAppIdPair accessTokenAppId,
        GraphRequest request,
        GraphResponse response,
        SessionEventsState sessionEventsState,
        FlushStatistics flushState) {
    FacebookRequestError error = response.getError();
    String resultDescription = "Success";

    FlushResult flushResult = FlushResult.SUCCESS;

    if (error != null) {
        final int NO_CONNECTIVITY_ERROR_CODE = -1;
        if (error.getErrorCode() == NO_CONNECTIVITY_ERROR_CODE) {
            resultDescription = "Failed: No Connectivity";
            flushResult = FlushResult.NO_CONNECTIVITY;
        } else {
            resultDescription = String.format("Failed:\n  Response: %s\n  Error %s",
                    response.toString(),
                    error.toString());
            flushResult = FlushResult.SERVER_ERROR;
        }
    }

    if (FacebookSdk.isLoggingBehaviorEnabled(LoggingBehavior.APP_EVENTS)) {
        String eventsJsonString = (String) request.getTag();
        String prettyPrintedEvents;

        try {
            JSONArray jsonArray = new JSONArray(eventsJsonString);
            prettyPrintedEvents = jsonArray.toString(2);
        } catch (JSONException exc) {
            prettyPrintedEvents = "<Can't encode events for debug logging>";
        }

        Logger.log(LoggingBehavior.APP_EVENTS, TAG,
                "Flush completed\nParams: %s\n  Result: %s\n  Events JSON: %s",
                request.getGraphObject().toString(),
                resultDescription,
                prettyPrintedEvents);
    }

    sessionEventsState.clearInFlightAndStats(error != null);

    if (flushResult == FlushResult.NO_CONNECTIVITY) {
        // We may call this for multiple requests in a batch, which is slightly inefficient
        // since in principle we could call it once for all failed requests, but the impact is
        // likely to be minimal. We don't call this for other server errors, because if an event
        // failed because it was malformed, etc., continually retrying it will cause subsequent
        // events to not be logged either.
        PersistedEvents.persistEvents(applicationContext, accessTokenAppId, sessionEventsState);
    }

    if (flushResult != FlushResult.SUCCESS) {
        // We assume that connectivity issues are more significant to report than server issues.
        if (flushState.result != FlushResult.NO_CONNECTIVITY) {
            flushState.result = flushResult;
        }
    }
}