/*
*
* Copyright (C) 2007-2015 Licensed to the Comunes Association (CA) under
* one or more contributor license agreements (see COPYRIGHT for details).
* The CA licenses this file to you under the GNU Affero General Public
* License version 3, (the "License"); you may not use this file except in
* compliance with the License. This file is part of kune.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
package cc.kune.core.client.state.impl;
import org.waveprotocol.wave.client.events.ClientEvents;
import org.waveprotocol.wave.client.events.WaveSelectionEvent;
import org.waveprotocol.wave.model.waveref.InvalidWaveRefException;
import org.waveprotocol.wave.util.escapers.GwtWaverefEncoder;
import cc.kune.common.client.actions.BeforeActionCollection;
import cc.kune.common.client.actions.BeforeActionListener;
import cc.kune.common.client.log.Log;
import cc.kune.common.client.notify.NotifyLevel;
import cc.kune.common.client.notify.ProgressHideEvent;
import cc.kune.common.shared.utils.Pair;
import cc.kune.common.shared.utils.TextUtils;
import cc.kune.core.client.auth.SignIn;
import cc.kune.core.client.events.AppStartEvent;
import cc.kune.core.client.events.AppStartEvent.AppStartHandler;
import cc.kune.core.client.events.GoHomeEvent;
import cc.kune.core.client.events.GroupChangedEvent;
import cc.kune.core.client.events.GroupChangedEvent.GroupChangedHandler;
import cc.kune.core.client.events.SocialNetworkChangedEvent;
import cc.kune.core.client.events.SocialNetworkChangedEvent.SocialNetworkChangedHandler;
import cc.kune.core.client.events.StateChangedEvent;
import cc.kune.core.client.events.StateChangedEvent.StateChangedHandler;
import cc.kune.core.client.events.ToolChangedEvent;
import cc.kune.core.client.events.ToolChangedEvent.ToolChangedHandler;
import cc.kune.core.client.events.UserSignInEvent;
import cc.kune.core.client.events.UserSignOutEvent;
import cc.kune.core.client.rpcservices.AsyncCallbackSimple;
import cc.kune.core.client.sitebar.spaces.Space;
import cc.kune.core.client.sitebar.spaces.SpaceConfEvent;
import cc.kune.core.client.sitebar.spaces.SpaceSelectEvent;
import cc.kune.core.client.state.ContentCache;
import cc.kune.core.client.state.HistoryTokenCallback;
import cc.kune.core.client.state.HistoryWrapper;
import cc.kune.core.client.state.Session;
import cc.kune.core.client.state.SiteTokenListeners;
import cc.kune.core.client.state.SiteTokens;
import cc.kune.core.client.state.StateManager;
import cc.kune.core.client.state.TokenMatcher;
import cc.kune.core.client.state.TokenUtils;
import cc.kune.core.shared.domain.utils.StateToken;
import cc.kune.core.shared.dto.SocialNetworkDataDTO;
import cc.kune.core.shared.dto.StateAbstractDTO;
import cc.kune.gspace.client.actions.ShowHelpContainerEvent;
import com.google.gwt.event.logical.shared.ValueChangeEvent;
import com.google.gwt.event.logical.shared.ValueChangeHandler;
import com.google.inject.Inject;
import com.google.inject.Provider;
import com.google.web.bindery.event.shared.EventBus;
import com.google.web.bindery.event.shared.HandlerRegistration;
/**
* The Class StateManagerDefault.
*
* @author danigb@gmail.com
* @author vjrj@ourproject.org (Vicente J. Ruiz Jurado)
*/
public class StateManagerDefault implements StateManager, ValueChangeHandler<String> {
/**
* The Interface OnFinishGetContent.
*
* @author danigb@gmail.com
* @author vjrj@ourproject.org (Vicente J. Ruiz Jurado)
*/
public interface OnFinishGetContent {
/**
* Finish.
*/
void finish();
}
/** The before state change collection. */
private final BeforeActionCollection beforeStateChangeCollection;
/** The content cache. */
private final ContentCache contentCache;
/** The event bus. */
private final EventBus eventBus;
/** The history. */
private final HistoryWrapper history;
/** The previous group token. */
private StateToken previousGroupToken;
/** The previous hash. */
private String previousHash;
/**
* When a historyChanged is interrupted (for instance because you are editing
* something), the new history token is stored here.
*/
private String resumedHistoryToken;
/** The session. */
private final Session session;
/** The sign in. */
private final Provider<SignIn> signIn;
/** The site tokens. */
private final SiteTokenListeners siteTokens;
/**
* Instantiates a new state manager default.
*
* @param contentProvider
* the content provider
* @param session
* the session
* @param history
* the history
* @param tokenMatcher
* the token matcher
* @param eventBus
* the event bus
* @param siteTokens
* the site tokens
* @param signIn
* the sign in
*/
@Inject
public StateManagerDefault(final ContentCache contentProvider, final Session session,
final HistoryWrapper history, final EventBus eventBus, final SiteTokenListeners siteTokens,
final Provider<SignIn> signIn) {
this.eventBus = eventBus;
this.contentCache = contentProvider;
this.session = session;
this.history = history;
this.signIn = signIn;
this.previousGroupToken = null;
this.previousHash = null;
this.resumedHistoryToken = null;
this.siteTokens = siteTokens;
beforeStateChangeCollection = new BeforeActionCollection();
TokenMatcher.init(GwtWaverefEncoder.INSTANCE);
session.onAppStart(true, new AppStartHandler() {
@Override
public void onAppStart(final AppStartEvent event) {
session.onUserSignIn(false, new UserSignInEvent.UserSignInHandler() {
@Override
public void onUserSignIn(final UserSignInEvent event) {
// refreshCurrentGroupState();
}
});
session.onUserSignOut(false, new UserSignOutEvent.UserSignOutHandler() {
@Override
public void onUserSignOut(final UserSignOutEvent event) {
refreshCurrentStateWithoutCache();
}
});
processCurrentHistoryToken();
}
});
onSocialNetworkChanged(false, new SocialNetworkChangedHandler() {
@Override
public void onSocialNetworkChanged(final SocialNetworkChangedEvent event) {
contentCache.removeCacheOfGroup(event.getState().getStateToken().getGroup());
}
});
eventBus.addHandler(GoHomeEvent.getType(), new GoHomeEvent.GoHomeHandler() {
@Override
public void onGoHome(final GoHomeEvent event) {
gotoDefaultHomepage();
}
});
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#addBeforeStateChangeListener(cc.
* kune.common.client.actions.BeforeActionListener)
*/
@Override
public void addBeforeStateChangeListener(final BeforeActionListener listener) {
beforeStateChangeCollection.add(listener);
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#addSiteToken(java.lang.String,
* cc.kune.core.client.state.HistoryTokenCallback)
*/
@Override
public void addSiteToken(final String token, final HistoryTokenCallback callback) {
siteTokens.put(token.toLowerCase(), callback);
}
/**
* Check group and tool change.
*
* @param newState
* the new state
*/
private void checkGroupAndToolChange(final StateAbstractDTO newState) {
final String newGroup = newState.getStateToken().getGroup();
final String previousGroup = getPreviousGroup();
if (startingUp() || !previousGroup.equals(newGroup)) {
Log.debug("New group: " + newGroup);
GroupChangedEvent.fire(eventBus, previousGroup, newGroup);
}
final String previousToolName = getPreviousTool();
final String newTokenTool = newState.getStateToken().getTool();
final String newToolName = newTokenTool == null ? "" : newTokenTool;
if (startingUp() || previousToolName == null || !previousToolName.equals(newToolName)) {
Log.debug("New tool: " + newToolName);
ToolChangedEvent.fire(eventBus, previousGroupToken, newState.getStateToken());
}
}
/**
* Do action or sign in if needed.
*
* @param tokenListener
* the token listener
* @param currentToken
* the current token
* @param secondPart
* the second part
*/
private void doActionOrSignInIfNeeded(final HistoryTokenCallback tokenListener,
final String currentToken, final String firstPart, final String secondPart) {
// First of all we see if we are starting up, and we get the def content
// first
if (startingUp()) {
// Starting with some token like "signin": load defContent first
Log.debug("Starting up with a token like #signin or #token(param): load defContent first");
getContent(new StateToken(SiteTokens.GROUP_HOME), false, new OnFinishGetContent() {
@Override
public void finish() {
doActionOrSignInIfNeededAfterStarted(tokenListener, currentToken, firstPart, secondPart);
}
});
} else {
doActionOrSignInIfNeededAfterStarted(tokenListener, currentToken, firstPart, secondPart);
}
}
/**
* Do action or sign in if needed started.
*
* @param tokenListener
* the token listener
* @param currentToken
* the current token
* @param secondPart
* the second part
*/
private void doActionOrSignInIfNeededAfterStarted(final HistoryTokenCallback tokenListener,
final String currentToken, final String firstPart, final String secondPart) {
if (tokenListener.authMandatory() && session.isNotLogged()) {
Log.debug("login mandatory for " + currentToken);
// Ok, we have to redirect because this token (for instance
// #translate) needs the user authenticated
final String infoMessage = tokenListener.getInfoMessage();
if (TextUtils.notEmpty(infoMessage)) {
signIn.get().setErrorMessage(infoMessage, NotifyLevel.info);
}
if (SiteTokens.SIGN_IN.equals(firstPart)) {
signIn.get().showSignInDialog(secondPart);
} else {
redirectButSignInBefore(currentToken);
}
} else {
// The auth is not mandatory, go ahead with the token action
Log.debug("Executing action related with historytoken " + secondPart);
tokenListener.onHistoryToken(secondPart);
}
}
/**
* Gets the content.
*
* @param newState
* the new state
* @return the content
*/
private void getContent(final StateToken newState) {
Log.debug("Get Content: " + newState);
getContent(newState, false);
}
/**
* Gets the content.
*
* @param newState
* the new state
* @param setBrowserHistory
* the set browser history
* @return the content
*/
private void getContent(final StateToken newState, final boolean setBrowserHistory) {
final OnFinishGetContent doNothing = new OnFinishGetContent() {
@Override
public void finish() {
// Do nothing
}
};
getContent(newState, setBrowserHistory, doNothing);
}
/**
* Gets the content.
*
* @param newState
* the new state
* @param setBrowserHistory
* the set browser history
* @param andThen
* the and then
* @return the content
*/
private void getContent(final StateToken newState, final boolean setBrowserHistory,
final OnFinishGetContent andThen) {
// NotifyUser.info("loading: " + newState + " because current:" +
// session.getCurrentStateToken());
contentCache.getContent(session.getUserHash(), newState,
new AsyncCallbackSimple<StateAbstractDTO>() {
@Override
public void onSuccess(final StateAbstractDTO newState) {
Log.debug("Retrived new state sucessfully");
setState(newState);
final String currentToken = newState.getStateToken().toString();
SpaceConfEvent.fire(eventBus, Space.groupSpace, currentToken);
SpaceConfEvent.fire(eventBus, Space.publicSpace, TokenUtils.preview(currentToken));
if (setBrowserHistory) {
previousHash = history.getToken();
history.newItem(currentToken, false);
SpaceSelectEvent.fire(eventBus, Space.groupSpace);
}
// if (newState instanceof StateContentDTO) {
// final StateContentDTO cnt = (StateContentDTO) newState;
// }
andThen.finish();
}
});
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#getCurrentToken()
*/
@Override
public String getCurrentToken() {
return history.getToken();
}
/**
* Gets the previous group.
*
* @return the previous group
*/
private String getPreviousGroup() {
final String previousGroup = startingUp() ? "" : previousGroupToken.getGroup();
return previousGroup;
}
/**
* Gets the previous tool.
*
* @return the previous tool
*/
private String getPreviousTool() {
final String previousTool = startingUp() ? "" : previousGroupToken.getTool();
return previousTool;
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#gotoDefaultHomepage()
*/
@Override
public void gotoDefaultHomepage() {
Log.debug("Goto def page called");
getContent(new StateToken(SiteTokens.GROUP_HOME), true);
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#gotoHistoryToken(java.lang.String)
*/
@Override
public void gotoHistoryToken(final String token) {
Log.debug("StateManager: history goto-string-token: " + token);
previousHash = history.getToken();
history.newItem(token);
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#gotoHistoryTokenButRedirectToCurrent
* (java.lang.String)
*/
@Override
public void gotoHistoryTokenButRedirectToCurrent(final String token) {
gotoHistoryToken(TokenUtils.addRedirect(token, history.getToken()));
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#gotoHomeSpace()
*/
@Override
public void gotoHomeSpace() {
gotoHistoryToken(SiteTokens.HOME);
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#gotoStateToken(cc.kune.core.shared
* .domain.utils.StateToken)
*/
@Override
public void gotoStateToken(final StateToken newToken) {
Log.debug("StateManager: history goto-token: " + newToken + ", previous: " + previousGroupToken);
previousHash = history.getToken();
history.newItem(newToken.getEncoded());
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#gotoStateToken(cc.kune.core.shared
* .domain.utils.StateToken, boolean)
*/
@Override
public void gotoStateToken(final StateToken token, final boolean useCache) {
if (!useCache) {
contentCache.remove(token);
}
gotoStateToken(token);
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#onGroupChanged(boolean,
* cc.kune.core.client.events.GroupChangedEvent.GroupChangedHandler)
*/
@Override
public HandlerRegistration onGroupChanged(final boolean fireNow, final GroupChangedHandler handler) {
final HandlerRegistration handlerReg = eventBus.addHandler(GroupChangedEvent.getType(), handler);
final StateAbstractDTO currentState = session.getCurrentState();
if (fireNow && currentState != null) {
handler.onGroupChanged(new GroupChangedEvent(getPreviousGroup(),
currentState.getStateToken().getGroup()));
}
return handlerReg;
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#onSocialNetworkChanged(boolean,
* cc
* .kune.core.client.events.SocialNetworkChangedEvent.SocialNetworkChangedHandler
* )
*/
@Override
public HandlerRegistration onSocialNetworkChanged(final boolean fireNow,
final SocialNetworkChangedHandler handler) {
final HandlerRegistration handlerReg = eventBus.addHandler(SocialNetworkChangedEvent.getType(),
handler);
final StateAbstractDTO currentState = session.getCurrentState();
if (fireNow && currentState != null) {
handler.onSocialNetworkChanged(new SocialNetworkChangedEvent(currentState));
}
return handlerReg;
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#onStateChanged(boolean,
* cc.kune.core.client.events.StateChangedEvent.StateChangedHandler)
*/
@Override
public HandlerRegistration onStateChanged(final boolean fireNow, final StateChangedHandler handler) {
final HandlerRegistration handlerReg = eventBus.addHandler(StateChangedEvent.getType(), handler);
final StateAbstractDTO currentState = session.getCurrentState();
if (fireNow && currentState != null) {
handler.onStateChanged(new StateChangedEvent(currentState));
}
return handlerReg;
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#onToolChanged(boolean,
* cc.kune.core.client.events.ToolChangedEvent.ToolChangedHandler)
*/
@Override
public HandlerRegistration onToolChanged(final boolean fireNow, final ToolChangedHandler handler) {
final HandlerRegistration handlerReg = eventBus.addHandler(ToolChangedEvent.getType(), handler);
final StateAbstractDTO currentState = session.getCurrentState();
if (fireNow && currentState != null) {
handler.onToolChanged(new ToolChangedEvent(previousGroupToken, currentState.getStateToken()));
}
return handlerReg;
}
/*
* (non-Javadoc)
*
* @see
* com.google.gwt.event.logical.shared.ValueChangeHandler#onValueChange(com
* .google.gwt.event.logical.shared.ValueChangeEvent)
*/
@Override
public void onValueChange(final ValueChangeEvent<String> event) {
Log.debug("History event value changed: " + event.getValue());
// First of all check that we are generating this #!fragment urls, later
history.checkHashbang();
processHistoryToken(HistoryUtils.undoHashbang(event.getValue()));
}
/**
* Process current history token.
*/
private void processCurrentHistoryToken() {
processHistoryToken(history.getToken());
}
/**
* Process #history token changes (this method should be rewritten).
*
* @param newToken
* the new token
*/
void processHistoryToken(final String newToken) {
// http://code.google.com/p/google-web-toolkit-doc-1-5/wiki/DevGuideHistory
if (beforeStateChangeCollection.checkBeforeAction()) {
// There isn't a beforeStateChange listener that stops this history
// change
// WARNING: String.toLowerCase breaks Wave URls
final HistoryTokenCallback tokenListener = newToken != null ? siteTokens.get(newToken.toLowerCase())
: null;
boolean isSpecialHash = false;
Log.debug("StateManager: on history changed '" + newToken + "'");
if (tokenListener != null) {
isSpecialHash = true;
Log.debug("token is one of #newgroup #signin #translate without #hash(redirection) ...");
doActionOrSignInIfNeeded(tokenListener, newToken, newToken, newToken);
} else {
Log.debug("Is not a special hash like #newgroup, etc, or maybe has a #hash(redirection)");
// token is not one of #newgroup #signin #translate ...
final String newTokenLower = newToken != null ? newToken.toLowerCase() : null;
if (newTokenLower != null && TokenMatcher.hasRedirect(newTokenLower)) {
final Pair<String, String> redirect = TokenMatcher.getRedirect(newToken);
final String firstToken = redirect.getLeft().toLowerCase();
final String sndToken = redirect.getRight();
final StateToken sndTokenT = new StateToken(sndToken);
if (firstToken.equals(SiteTokens.PREVIEW)) {
SpaceSelectEvent.fire(eventBus, Space.publicSpace);
SpaceConfEvent.fire(eventBus, Space.groupSpace, sndToken);
SpaceConfEvent.fire(eventBus, Space.publicSpace, TokenUtils.preview(sndToken));
getContent(sndTokenT);
// Don't continue
return;
} else if (firstToken.equals(SiteTokens.TUTORIAL)) {
getContent(sndTokenT, true, new OnFinishGetContent() {
@Override
public void finish() {
ShowHelpContainerEvent.fire(eventBus, sndTokenT.getTool());
}
});
// Don't continue
return;
} else {
final HistoryTokenCallback tokenWithRedirect = siteTokens.get(firstToken);
if (tokenWithRedirect != null) {
isSpecialHash = true;
Log.debug("Is some #subtitle(foo) or #verifyemail(hash) etc, firstToken " + firstToken);
doActionOrSignInIfNeeded(tokenWithRedirect, newToken, firstToken, sndToken);
}
}
}
if (TokenMatcher.isWaveToken(newToken)) {
if (session.isLogged()) {
SpaceConfEvent.fire(eventBus, Space.userSpace, newToken);
SpaceSelectEvent.fire(eventBus, Space.userSpace);
try {
ClientEvents.get().fireEvent(
new WaveSelectionEvent(GwtWaverefEncoder.decodeWaveRefFromPath(newToken)));
} catch (final InvalidWaveRefException e) {
Log.error(newToken, e);
}
} else {
// Wave, but don't logged
redirectButSignInBefore(newToken);
if (startingUp()) {
// Starting application (with Wave)
getContent(new StateToken(SiteTokens.GROUP_HOME), false);
}
}
} else if (!isSpecialHash) {
// FIXME This can be in the top of isWaveToken....
if (TokenMatcher.isGroupToken(newToken)) {
Log.debug("StateManager: is a group token: '" + newToken + "'");
SpaceConfEvent.fire(eventBus, Space.groupSpace, newToken);
SpaceConfEvent.fire(eventBus, Space.publicSpace, TokenUtils.preview(newToken));
SpaceSelectEvent.fire(eventBus, Space.groupSpace);
getContent(new StateToken(newToken));
} else {
Log.debug("Last option, get default with token: " + newToken);
getContent(new StateToken(SiteTokens.GROUP_HOME), false);
}
}
}
} else {
resumedHistoryToken = newToken;
}
}
/**
* Redirect but sign in before.
*
* @param newHistoryToken
* the new history token
*/
private void redirectButSignInBefore(final String newHistoryToken) {
history.newItem(TokenUtils.addRedirect(SiteTokens.SIGN_IN, newHistoryToken));
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#redirectOrRestorePreviousToken(boolean
* )
*/
@Override
public void redirectOrRestorePreviousToken(final boolean fireChange) {
final String token = history.getToken();
if (TokenMatcher.hasRedirect(token)) {
// URL of the form signin(group.tool)
final String previousToken = TokenMatcher.getRedirect(token).getRight();
if (previousToken.equals(SiteTokens.WAVE_INBOX) && session.isNotLogged()) {
// signin(inbox) && cancel
restorePreviousToken(fireChange);
} else {
history.newItem(previousHash);
}
} else {
// No redirect then restore previous token
restorePreviousToken(fireChange);
}
}
/**
* <p>
* Reload current state (using client cache if available)
* </p>
* .
*/
@Override
public void refreshCurrentState() {
processHistoryToken(history.getToken());
}
/**
* <p>
* Reload current state (not using client cache)
* </p>
* .
*/
@Override
public void refreshCurrentStateWithoutCache() {
final StateToken currentStateToken = session.getCurrentStateToken();
if (currentStateToken == null) {
processCurrentHistoryToken();
} else {
contentCache.remove(currentStateToken);
getContent(currentStateToken);
}
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#removeBeforeStateChangeListener(
* cc.kune.common.client.actions.BeforeActionListener)
*/
@Override
public void removeBeforeStateChangeListener(final BeforeActionListener listener) {
beforeStateChangeCollection.remove(listener);
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#removeCache(cc.kune.core.shared.
* domain.utils.StateToken)
*/
@Override
public void removeCache(final StateToken parentToken) {
contentCache.remove(parentToken);
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#removeCacheOfGroup(java.lang.String)
*/
@Override
public void removeCacheOfGroup(final String group) {
contentCache.removeCacheOfGroup(group);
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#removeSiteToken(java.lang.String)
*/
@Override
public void removeSiteToken(final String token) {
siteTokens.remove(token);
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#restorePreviousToken(boolean)
*/
@Override
public void restorePreviousToken(final boolean fireChange) {
if (previousHash != null) {
if (fireChange) {
gotoHistoryToken(previousHash);
} else {
setHistoryStateToken(previousHash);
}
}
}
/*
* (non-Javadoc)
*
* @see cc.kune.core.client.state.StateManager#resumeTokenChange()
*/
@Override
public void resumeTokenChange() {
if (resumedHistoryToken != null) {
// Is this reload redundant?
refreshCurrentState();
gotoHistoryToken(resumedHistoryToken);
resumedHistoryToken = null;
}
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#setHistoryStateToken(java.lang.String
* )
*/
@Override
public void setHistoryStateToken(final String newToken) {
Log.debug("StateManager: history goto-token: " + newToken + ", previous: " + previousGroupToken);
previousHash = history.getToken();
history.newItem(newToken, false);
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#setRetrievedState(cc.kune.core.shared
* .dto.StateAbstractDTO)
*/
@Override
public void setRetrievedState(final StateAbstractDTO newState) {
contentCache.cache(newState.getStateToken(), newState);
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#setRetrievedStateAndGo(cc.kune.core
* .shared.dto.StateAbstractDTO)
*/
@Override
public void setRetrievedStateAndGo(final StateAbstractDTO newState) {
setRetrievedState(newState);
final String token = newState.getStateToken().toString();
if (history.getToken().equals(token)) {
setState(newState);
}
previousHash = history.getToken();
history.newItem(token);
}
/*
* (non-Javadoc)
*
* @see
* cc.kune.core.client.state.StateManager#setSocialNetwork(cc.kune.core.shared
* .dto.SocialNetworkDataDTO)
*/
@Override
public void setSocialNetwork(final SocialNetworkDataDTO socialNet) {
StateAbstractDTO state;
if (session != null && (state = session.getCurrentState()) != null) {
// After a SN operation, usually returns a SocialNetworkResultDTO
// with new SN data and we refresh the state
// to avoid to reload() again the state
state.setSocialNetworkData(socialNet);
SocialNetworkChangedEvent.fire(eventBus, state);
}
}
/**
* Sets the state.
*
* @param newState
* the new state
*/
void setState(final StateAbstractDTO newState) {
session.setCurrentState(newState);
final StateToken newToken = newState.getStateToken();
Log.debug("Set new state: " + newToken);
contentCache.cache(newToken, newState);
// history.newItem(newToken.toString(), false);
StateChangedEvent.fire(eventBus, newState);
checkGroupAndToolChange(newState);
previousGroupToken = newToken.copy();
eventBus.fireEvent(new ProgressHideEvent());
}
/**
* Starting up.
*
* @return true, if successful
*/
private boolean startingUp() {
return previousGroupToken == null;
}
}