Java Log.d方法代码示例

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
/**
 * @note return value should not be null.
 */
private Document _getDocument(String docID) throws CouchbaseLiteException {
    Document doc;
    try {
        doc = forest.getDocument(docID, true);
    } catch (ForestException e) {
        Log.d(TAG, "ForestDB Warning: getDocument(docID, true) docID=[%s] error=[%s]",
                docID, e.toString());
        throw new CouchbaseLiteException(ForestBridge.err2status(e));
    }
    if (!doc.exists()) {
        doc.free();
        throw new CouchbaseLiteException(Status.NOT_FOUND);
    }
    return doc;
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
/**
 * Fire a trigger to the state machine
 */
protected void fireTrigger(final ReplicationTrigger trigger) {
    Log.d(Log.TAG_SYNC, "%s [fireTrigger()] => " + trigger, this);
    // All state machine triggers need to happen on the replicator thread
    synchronized (executor) {
        if (!executor.isShutdown()) {
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        Log.d(Log.TAG_SYNC, "firing trigger: %s", trigger);
                        stateMachine.fire(trigger);
                    } catch (Exception e) {
                        Log.i(Log.TAG_SYNC, "Error in StateMachine.fire(trigger): %s", e.getMessage());
                        throw new RuntimeException(e);
                    }
                }
            });
        }
    }
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
/**
 * Retry replication if previous attempt ends with error
 */
protected void retryReplicationIfError() {
    Log.d(TAG, "retryReplicationIfError() state=" + stateMachine.getState() +
            ", error=" + this.error +
            ", isContinuous()=" + isContinuous() +
            ", isTransientError()=" + Utils.isTransientError(this.error));

    // Make sure if state is IDLE, this method should be called when state becomes IDLE
    if (!stateMachine.getState().equals(ReplicationState.IDLE))
        return;

    if (this.error != null) {
        // IDLE_ERROR
        if (isContinuous()) {
            // 12/16/2014 - only retry if error is transient error 50x http error
            // It may need to retry for any kind of errors
            if (Utils.isTransientError(this.error)) {
                onBeforeScheduleRetry();
                cancelRetryFuture();
                scheduleRetryFuture();
            }
        }
    }
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
public boolean receivedChange(final Map<String, Object> change) {
    // wait if paused flag is on.
    waitIfPaused();
    // check if still running
    if (running) {
        Object seq = change.get("seq");
        if (seq == null) {
            return false;
        }
        //pass the change to the client on the thread that created this change tracker
        if (client != null) {
            Log.d(Log.TAG_CHANGE_TRACKER, "%s: changeTrackerReceivedChange: %s", this, change);
            client.changeTrackerReceivedChange(change);
            Log.d(Log.TAG_CHANGE_TRACKER, "%s: /changeTrackerReceivedChange: %s", this, change);

        }
        lastSequenceID = seq;
    }
    return true;
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
/**
 * Releases all resources used by the Manager instance and closes all its databases.
 */
@InterfaceAudience.Public
public void close() {
    synchronized (lockDatabases) {
        Log.d(Database.TAG, "Closing " + this);

        // Close all database:
        // Snapshot of the current open database to avoid concurrent modification as
        // the database will be forgotten (removed from the databases map) when it is closed:
        Database[] openDbs = databases.values().toArray(new Database[databases.size()]);
        for (Database database : openDbs)
            database.close();
        databases.clear();

        // Stop reachability:
        context.getNetworkReachabilityManager().stopListening();

        // Shutdown ScheduledExecutorService:
        if (workExecutor != null && !workExecutor.isShutdown())
            Utils.shutdownAndAwaitTermination(workExecutor);

        Log.d(Database.TAG, "Closed " + this);
    }
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
/**
 * Starts observing database changes. The .rows property will now update automatically. (You
 * usually don't need to call this yourself, since calling getRows() will start it for you
 */
@InterfaceAudience.Public
public void start() {

    if (runningState.get() == true) {
        Log.v(Log.TAG_QUERY, "%s: start() called, but runningState is already true.  Ignoring.", this);
        return;
    } else {
        Log.d(Log.TAG_QUERY, "%s: start() called", this);
        runningState.set(true);
    }

    if (!observing) {
        observing = true;
        getDatabase().addChangeListener(this);
        Log.v(Log.TAG_QUERY, "%s: start() is calling update()", this);
        update();
    }
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
private boolean isTransientError(Response response, Throwable e) {
    Log.d(TAG, "%s: isTransientError, httpResponse: %s e: %s", this, response, e);
    if (response != null) {
        Log.d(TAG, "%s: isTransientError, status code: %d",
                this, response.code());
        if (Utils.isTransientError(response)) {
            Log.d(TAG, "%s: isTransientError, detect a transient error", this);
            return true;
        }
    }
    if (response == null || response.code() < 400) {
        if (e instanceof IOException) {
            Log.d(TAG, "%s: isTransientError, detect an IOException which is a transient error", this);
            return true;
        }
    }
    Log.d(TAG, "%s: isTransientError, return false", this);
    return false;
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
/**
 * @exclude
 */
@InterfaceAudience.Private
public CustomFuture sendAsyncRequest(String method,
                                     URL url,
                                     boolean cancelable,
                                     Map<String, ?> body,
                                     boolean dontLog404,
                                     final RemoteRequestCompletion onCompletion) {
    Log.d(Log.TAG_SYNC, "[sendAsyncRequest()] " + method + " => " + url);
    RemoteRequestRetry request = new RemoteRequestRetry(
            RemoteRequestRetry.RemoteRequestType.REMOTE_REQUEST,
            remoteRequestExecutor,
            executor,
            clientFactory,
            method,
            url,
            serverIsSyncGateway(),
            cancelable,
            body,
            null,
            getLocalDatabase(),
            getHeaders(),
            onCompletion
    );
    request.setDontLog404(dontLog404);
    request.setAuthenticator(getAuthenticator());
    request.setOnPreCompletionCaller(new RemoteRequestCompletion() {
        @Override
        public void onCompletion(RemoteRequest remoteRequest, Response response, Object result, Throwable e) {
            if (serverType == null && response != null) {
                String serverVersion = response.header("Server");
                if (serverVersion != null) {
                    Log.v(Log.TAG_SYNC, "serverVersion: %s", serverVersion);
                    serverType = serverVersion;
                }
            }
        }
    });
    return request.submit(canSendCompressedRequests());
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
@Override
public void run() {
    Log.d(Log.TAG_CHANGE_TRACKER, "Thread id => " + Thread.currentThread().getId());
    try {
        runLoop();
    } finally {
        // stopped() method should be called at end of run() method.
        stopped();
    }
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
public boolean start() {
    Log.d(Log.TAG_CHANGE_TRACKER, "%s: Changed tracker asked to start", this);
    running = true;
    this.error = null;
    String maskedRemoteWithoutCredentials = databaseURL.toExternalForm();
    maskedRemoteWithoutCredentials = maskedRemoteWithoutCredentials.replaceAll("://.*:.*@", "://---:[email protected]");
    thread = new Thread(this, "ChangeTracker-" + maskedRemoteWithoutCredentials);
    thread.start();
    return true;
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
private void stopped() {
    Log.d(Log.TAG_CHANGE_TRACKER, "%s: Change tracker in stopped()", this);
    running = false; // in case stop() method was not called to stop
    if (client != null) {
        Log.d(Log.TAG_CHANGE_TRACKER, "%s: Change tracker calling changeTrackerStopped, client: %s", this, client);
        client.changeTrackerStopped(ChangeTracker.this);
    } else {
        Log.d(Log.TAG_CHANGE_TRACKER, "%s: Change tracker not calling changeTrackerStopped, client == null", this);
    }
    client = null;
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
protected void startChangeTracker() {
    // make sure not start new changeTracker if pull replicator is not running or idle
    if (!(stateMachine.isInState(ReplicationState.RUNNING) ||
            stateMachine.isInState(ReplicationState.IDLE)))
        return;

    // if changeTracker is already running, not start new one.
    if (changeTracker != null && changeTracker.isRunning())
        return;

    ChangeTracker.ChangeTrackerMode changeTrackerMode;

    // it always starts out as OneShot, but if its a continuous replication
    // it will switch to longpoll later.
    changeTrackerMode = ChangeTracker.ChangeTrackerMode.OneShot;

    Log.d(TAG, "%s: starting ChangeTracker with since=%s mode=%s",
            this, lastSequence, changeTrackerMode);
    changeTracker = new ChangeTracker(remote, changeTrackerMode, true, lastSequence, this);
    changeTracker.setAuthenticator(getAuthenticator());
    Log.d(TAG, "%s: started ChangeTracker %s", this, changeTracker);

    if (filterName != null) {
        changeTracker.setFilterName(filterName);
        if (filterParams != null) {
            changeTracker.setFilterParams(filterParams);
        }
    }
    changeTracker.setDocIDs(documentIDs);
    changeTracker.setRequestHeaders(requestHeaders);
    changeTracker.setContinuous(lifecycle == Replication.Lifecycle.CONTINUOUS);
    changeTracker.setActiveOnly(lastSequence == null && db.getDocumentCount() == 0);
    changeTracker.start();
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
public void sleepAppropriateAmountOfTime() {
    try {
        int sleepMilliseconds = getSleepMilliseconds();
        if (sleepMilliseconds > 0) {
            Log.d(Log.TAG_CHANGE_TRACKER, "%s: sleeping for %d", this, sleepMilliseconds);
            Thread.sleep(sleepMilliseconds);
        }
    } catch (InterruptedException e1) {
    }
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
private void dbClosing() {
    Log.d(TAG, "Database closing! Returning error 500");
    Status status = new Status(Status.INTERNAL_SERVER_ERROR);
    status = sendResponseHeaders(status);
    connection.setResponseCode(status.getCode());
    setResponse();
    sendResponse();
}
 

import com.couchbase.lite.util.Log; //导入方法依赖的package包/类
/**
 * in CBL_Puller.m
 * - (void) changeTrackerReceivedSequence: (id)remoteSequenceID
 * docID: (NSString*)docID
 * revIDs: (NSArray*)revIDs
 * deleted: (BOOL)deleted
 */
protected void processChangeTrackerChange(final Map<String, Object> change) {
    // Process each change from the feed:
    String docID = (String) change.get("id");
    if (docID == null || !Document.isValidDocumentId(docID))
        return;

    String lastSequence = change.get("seq").toString();
    boolean deleted = (change.containsKey("deleted") &&
            change.get("deleted").equals(Boolean.TRUE));
    List<Map<String, Object>> changes = (List<Map<String, Object>>) change.get("changes");
    for (Map<String, Object> changeDict : changes) {
        String revID = (String) changeDict.get("rev");
        if (revID == null) {
            continue;
        }

        PulledRevision rev = new PulledRevision(docID, revID, deleted);

        // Remember its remote sequence ID (opaque), and make up a numeric sequence
        // based on the order in which it appeared in the _changes feed:
        rev.setRemoteSequenceID(lastSequence);

        if (changes.size() > 1)
            rev.setConflicted(true);

        Log.d(TAG, "%s: adding rev to inbox %s", this, rev);

        Log.v(TAG,
                "%s: changeTrackerReceivedChange() incrementing changesCount by 1", this);

        // this is purposefully done slightly different than the ios version
        addToChangesCount(1);

        addToInbox(rev);
    }

    pauseOrResume();
}