Exemple #1
0
  private static boolean resetStateFromJSON(
      JSONObject state, String targetListName, IItemStateApplier stateApplier) {
    if (!state.has(targetListName)) {
      return true;
    }

    SoomlaUtils.LogDebug(TAG, "Resetting state for " + targetListName);

    try {
      JSONObject itemsJSON = state.getJSONObject(targetListName);
      Iterator keysIter = itemsJSON.keys();
      while (keysIter.hasNext()) {
        String itemId = (String) keysIter.next();
        JSONObject itemValuesJSON = itemsJSON.getJSONObject(itemId);
        if (!stateApplier.applyState(itemId, itemValuesJSON)) {
          return false;
        }
      }
    } catch (JSONException e) {
      SoomlaUtils.LogError(
          TAG, "Unable to set state for " + targetListName + ". error: " + e.getLocalizedMessage());
      return false;
    }

    return true;
  }
Exemple #2
0
  public static boolean resetLevelUpState(JSONObject state) {
    if (state == null) {
      return false;
    }

    SoomlaUtils.LogDebug(TAG, "Resetting state with: " + state.toString());

    clearCurrentState();

    SoomlaUtils.LogDebug(TAG, "Current state was cleared");

    return resetGatesStateFromJSON(state)
        && resetWorldsStateFromJSON(state)
        && resetMissionsStateFromJSON(state)
        && resetScoresStateFromJSON(state);
  }
  /** {@inheritDoc} */
  @Override
  public void updateStory(
      String message,
      String name,
      String caption,
      String description,
      String link,
      String picture,
      final SocialCallbacks.SocialActionListener socialActionListener) {
    if (!isInitialized) {
      return;
    }

    SoomlaUtils.LogDebug(TAG, "updateStory");

    RefProvider = getProvider();
    RefSocialActionListener = socialActionListener;

    preformingAction = ACTION_PUBLISH_STORY;

    try {
      twitter.updateStatus(message + " " + link);
    } catch (Exception e) {
      failListener(ACTION_PUBLISH_STORY, e.getMessage());
    }
  }
  /** {@inheritDoc} */
  @Override
  public void like(final Activity parentActivity, String pageId) {
    SoomlaUtils.LogDebug(TAG, "like");

    Intent browserIntent =
        new Intent(Intent.ACTION_VIEW, Uri.parse("https://www.twitter.com/" + pageId));
    parentActivity.startActivity(browserIntent);
  }
        /**
         * Called when a user's information has arrived from twitter
         *
         * @param user The user's details
         */
        @Override
        public void gotUserDetail(User user) {
          SoomlaUtils.LogDebug(TAG, "getUserProfile/onComplete");
          UserProfile userProfile = createUserProfile(user, true);

          RefUserProfileListener.success(userProfile);

          clearListener(ACTION_GET_USER_PROFILE);
        }
  private static void clearListener(int requestedAction) {
    SoomlaUtils.LogDebug(TAG, "Clearing Listeners " + requestedAction);

    switch (requestedAction) {
      case ACTION_LOGIN:
        {
          RefLoginListener = null;
          break;
        }
      case ACTION_PUBLISH_STATUS:
        {
          RefSocialActionListener = null;
          break;
        }
      case ACTION_PUBLISH_STATUS_DIALOG:
        {
          RefSocialActionListener = null;
          break;
        }
      case ACTION_PUBLISH_STORY:
        {
          RefSocialActionListener = null;
          break;
        }
      case ACTION_PUBLISH_STORY_DIALOG:
        {
          RefSocialActionListener = null;
          break;
        }
      case ACTION_UPLOAD_IMAGE:
        {
          RefSocialActionListener = null;
          break;
        }
      case ACTION_GET_FEED:
        {
          RefFeedListener = null;
          break;
        }
      case ACTION_GET_CONTACTS:
        {
          RefContactsListener = null;
          break;
        }
      case ACTION_GET_USER_PROFILE:
        {
          RefUserProfileListener = null;
          break;
        }
      default:
        {
          SoomlaUtils.LogWarning(TAG, "action unknown clear listener:" + requestedAction);
          break;
        }
    }
  }
  /** {@inheritDoc} */
  @Override
  public void updateStatusDialog(
      String link, SocialCallbacks.SocialActionListener socialActionListener) {
    if (!isInitialized) {
      return;
    }

    SoomlaUtils.LogDebug(TAG, "updateStatusDialog");
    socialActionListener.fail("Dialogs are not available in Twitter");
  }
  /** {@inheritDoc} */
  @Override
  public boolean isLoggedIn() {
    SoomlaUtils.LogDebug(TAG, "isLoggedIn");

    try {
      return isInitialized && (twitter.getOAuthAccessToken() != null);
    } catch (Exception e) {
      return false;
    }
  }
    /** {@inheritDoc} */
    @Override
    protected void onDestroy() {
      super.onDestroy();

      if (!mFinishedVerifying) {
        cancelLogin();
      }

      SoomlaUtils.LogDebug(TAG, "onDestroy");
    }
Exemple #10
0
  private static void applyGatesStateToJSON(JSONObject modelJSON, JSONObject stateJSON) {
    JSONObject gatesStateJSON = new JSONObject();
    HashMap<String, JSONObject> gates = getGates(modelJSON);
    for (JSONObject gateJSON : gates.values()) {
      JSONObject gateValuesJSON = new JSONObject();
      try {
        String gateId = gateJSON.getString("itemId");
        gateValuesJSON.put("open", GateStorage.isOpen(gateId));

        gatesStateJSON.put(gateId, gateValuesJSON);
      } catch (JSONException e) {
        SoomlaUtils.LogDebug(TAG, "Unable to get Gates state: " + e.getLocalizedMessage());
      }
    }

    try {
      stateJSON.put("gates", gatesStateJSON);
    } catch (JSONException e) {
      SoomlaUtils.LogDebug(TAG, "Unable to set Gates state: " + e.getLocalizedMessage());
    }
  }
Exemple #11
0
  private static void applyMissionsStateToJSON(JSONObject modelJSON, JSONObject stateJSON) {
    JSONObject missionsStateJSON = new JSONObject();
    HashMap<String, JSONObject> missions = getMissions(modelJSON);
    for (JSONObject missionJSON : missions.values()) {
      JSONObject missionValuesJSON = new JSONObject();
      try {
        String missionId = missionJSON.getString("itemId");
        missionValuesJSON.put("timesCompleted", MissionStorage.getTimesCompleted(missionId));

        missionsStateJSON.put(missionId, missionValuesJSON);
      } catch (JSONException e) {
        SoomlaUtils.LogDebug(TAG, "Unable to get Missions state: " + e.getLocalizedMessage());
      }
    }

    try {
      stateJSON.put("missions", missionsStateJSON);
    } catch (JSONException e) {
      SoomlaUtils.LogDebug(TAG, "Unable to set Missions state: " + e.getLocalizedMessage());
    }
  }
Exemple #12
0
  private static void applyWorldsStateToJSON(JSONObject modelJSON, JSONObject stateJSON) {
    JSONObject worldsStateJSON = new JSONObject();
    JSONObject levelsStateJSON = new JSONObject();

    HashMap<String, JSONObject> worlds = getWorlds(modelJSON);
    for (JSONObject worldJSON : worlds.values()) {
      JSONObject worldValuesJSON = new JSONObject();
      try {
        String worldId = worldJSON.getString("itemId");
        worldValuesJSON.put("completed", WorldStorage.isCompleted(worldId));
        worldValuesJSON.put("assignedReward", WorldStorage.getAssignedReward(worldId));
        worldValuesJSON.put(
            "lastCompletedInnerWorld", WorldStorage.getLastCompletedInnerWorld(worldId));

        worldsStateJSON.put(worldId, worldValuesJSON);

        if (worldJSON.getString("className").equals("Level")) {
          JSONObject levelValuesJSON = new JSONObject();
          levelValuesJSON.put("started", LevelStorage.getTimesStarted(worldId));
          levelValuesJSON.put("played", LevelStorage.getTimesPlayed(worldId));
          levelValuesJSON.put("timesCompleted", LevelStorage.getTimesCompleted(worldId));
          levelValuesJSON.put("last", LevelStorage.getLastDurationMillis(worldId));
          levelValuesJSON.put("slowest", LevelStorage.getSlowestDurationMillis(worldId));
          levelValuesJSON.put("fastest", LevelStorage.getFastestDurationMillis(worldId));

          levelsStateJSON.put(worldId, levelValuesJSON);
        }
      } catch (JSONException e) {
        SoomlaUtils.LogDebug(TAG, "Unable to get Worlds state: " + e.getLocalizedMessage());
      }
    }

    try {
      stateJSON.put("worlds", worldsStateJSON);
      stateJSON.put("levels", levelsStateJSON);
    } catch (JSONException e) {
      SoomlaUtils.LogDebug(TAG, "Unable to set Worlds state: " + e.getLocalizedMessage());
    }
  }
Exemple #13
0
  private static void applyScoresStateToJSON(JSONObject modelJSON, JSONObject stateJSON) {
    JSONObject scoresStateJSON = new JSONObject();
    HashMap<String, JSONObject> scores = getScores(modelJSON);
    for (JSONObject scoreJSON : scores.values()) {
      JSONObject scoreValuesJSON = new JSONObject();
      try {
        String scoreId = scoreJSON.getString("itemId");
        scoreValuesJSON.put("latest", ScoreStorage.getLatestScore(scoreId));
        scoreValuesJSON.put("record", ScoreStorage.getRecordScore(scoreId));

        scoresStateJSON.put(scoreId, scoreValuesJSON);
      } catch (JSONException e) {
        SoomlaUtils.LogDebug(TAG, "Unable to get Scores state: " + e.getLocalizedMessage());
      }
    }

    try {
      stateJSON.put("scores", scoresStateJSON);
    } catch (JSONException e) {
      SoomlaUtils.LogDebug(TAG, "Unable to set Scores state: " + e.getLocalizedMessage());
    }
  }
  /** {@inheritDoc} */
  @Override
  public void logout(final AuthCallbacks.LogoutListener logoutListener) {
    SoomlaUtils.LogDebug(TAG, "logout");

    KeyValueStorage.deleteKeyValue(getTwitterStorageKey(TWITTER_OAUTH_TOKEN));
    KeyValueStorage.deleteKeyValue(getTwitterStorageKey(TWITTER_OAUTH_SECRET));

    mainRequestToken = null;

    twitter.setOAuthAccessToken(null);
    twitter.shutdown();

    logoutListener.success();
  }
        /**
         * Called when the user's friends list has arrived
         *
         * @param users The user's friends (by Twitter definition)
         */
        @Override
        public void gotFriendsList(PagableResponseList<User> users) {
          SoomlaUtils.LogDebug(TAG, "getContacts/onComplete " + users.size());

          List<UserProfile> userProfiles = new ArrayList<UserProfile>();
          for (User profile : users) {
            userProfiles.add(createUserProfile(profile));
          }
          if (users.hasNext()) {
            lastContactCursor = users.getNextCursor();
          }
          RefContactsListener.success(userProfiles, users.hasNext());
          clearListener(ACTION_GET_CONTACTS);
        }
Exemple #16
0
  public static JSONObject getLevelUpModel() {
    JSONObject modelJSON = null;

    String model = KeyValueStorage.getValue(DB_KEY_PREFIX + "model");
    SoomlaUtils.LogDebug(TAG, "model: " + model);
    if (model == null) {
      return null;
    }

    try {
      modelJSON = new JSONObject(model);
    } catch (JSONException e) {
      SoomlaUtils.LogError(TAG, "Unable to parse LevelUp model into JSON");
    }

    return modelJSON;
  }
  /** {@inheritDoc} */
  @Override
  public void getUserProfile(final AuthCallbacks.UserProfileListener userProfileListener) {
    if (!isInitialized) {
      return;
    }

    SoomlaUtils.LogDebug(TAG, "getUserProfile");

    RefProvider = getProvider();
    RefUserProfileListener = userProfileListener;

    preformingAction = ACTION_GET_USER_PROFILE;

    try {
      twitter.showUser(twitterScreenName);
    } catch (Exception e) {
      failListener(ACTION_GET_USER_PROFILE, e.getMessage());
    }
  }
    private void completeVerify(Uri uri) {
      SoomlaUtils.LogDebug(TAG, "Verification complete");
      /** Handle OAuth Callback */
      if (uri != null && uri.toString().startsWith(oauthCallbackURL)) {
        String verifier = uri.getQueryParameter(OAUTH_VERIFIER);
        if (!TextUtils.isEmpty(verifier)) {
          twitter.getOAuthAccessTokenAsync(mainRequestToken, verifier);
        } else {
          // Without a verifier an Access Token cannot be received
          // happens when a user clicks "cancel"
          cancelLogin();
        }
      }

      webView.hide();
      finish();

      mFinishedVerifying = true;
    }
        /**
         * Called when the user's timeline has arrived
         *
         * @param statuses The user's latest statuses
         */
        @Override
        public void gotUserTimeline(ResponseList<Status> statuses) {
          SoomlaUtils.LogDebug(TAG, "getFeed/onComplete");

          List<String> feeds = new ArrayList<String>();
          for (Status post : statuses) {
            feeds.add(post.getText());
          }

          boolean hasMore;
          if (feeds.size() >= PAGE_SIZE) {
            lastFeedCursor++;
            hasMore = true;
          } else {
            lastFeedCursor = 1;
            hasMore = false;
          }
          RefFeedListener.success(feeds, hasMore);
          clearListener(ACTION_GET_FEED);
        }
  /** {@inheritDoc} */
  @Override
  public void updateStatus(
      String status, final SocialCallbacks.SocialActionListener socialActionListener) {
    if (!isInitialized) {
      return;
    }

    SoomlaUtils.LogDebug(TAG, "updateStatus");

    RefProvider = getProvider();
    RefSocialActionListener = socialActionListener;

    preformingAction = ACTION_PUBLISH_STATUS;

    try {
      twitter.updateStatus(status);
    } catch (Exception e) {
      failListener(ACTION_PUBLISH_STATUS, e.getMessage());
    }
  }
  /** {@inheritDoc} */
  @Override
  public void configure(Map<String, String> providerParams) {
    autoLogin = false;

    if (providerParams != null) {
      twitterConsumerKey = providerParams.get("consumerKey");
      twitterConsumerSecret = providerParams.get("consumerSecret");

      // extract autoLogin
      String autoLoginStr = providerParams.get("autoLogin");
      autoLogin = autoLoginStr != null && Boolean.parseBoolean(autoLoginStr);
    }

    SoomlaUtils.LogDebug(
        TAG,
        String.format(
            "ConsumerKey:%s ConsumerSecret:%s", twitterConsumerKey, twitterConsumerSecret));

    if (TextUtils.isEmpty(twitterConsumerKey) || TextUtils.isEmpty(twitterConsumerSecret)) {
      SoomlaUtils.LogError(
          TAG,
          "You must provide the Consumer Key and Secret in the SoomlaProfile initialization parameters");
      isInitialized = false;
    } else {
      isInitialized = true;
    }

    oauthCallbackURL = "oauth://soomla_twitter" + twitterConsumerKey;

    ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
    configurationBuilder.setOAuthConsumerKey(twitterConsumerKey);
    configurationBuilder.setOAuthConsumerSecret(twitterConsumerSecret);
    Configuration configuration = configurationBuilder.build();
    twitter = new AsyncTwitterFactory(configuration).getInstance();

    if (!actionsListenerAdded) {
      SoomlaUtils.LogWarning(TAG, "added action listener");
      twitter.addListener(actionsListener);
      actionsListenerAdded = true;
    }
  }
  /** {@inheritDoc} */
  @Override
  public void getContacts(
      boolean fromStart, final SocialCallbacks.ContactsListener contactsListener) {
    if (!isInitialized) {
      return;
    }

    SoomlaUtils.LogDebug(TAG, "getContacts");

    RefProvider = getProvider();
    RefContactsListener = contactsListener;

    preformingAction = ACTION_GET_USER_PROFILE;

    try {
      twitter.getFriendsList(twitterScreenName, fromStart ? -1 : this.lastContactCursor);
      this.lastContactCursor = -1;
    } catch (Exception e) {
      failListener(ACTION_GET_USER_PROFILE, e.getMessage());
    }
  }
    /** {@inheritDoc} */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);

      // Edge case - start activity without twitter
      if (twitter == null) {
        finish();
        return;
      }

      SoomlaUtils.LogDebug(TAG, "onCreate");

      if (webView == null) {
        webView = new SoomlaTwitterWebView(this);
        webView.setWebViewClient(
            new WebViewClient() {
              @Override
              public boolean shouldOverrideUrlLoading(WebView view, String url) {
                // See if the URL should be handled by the provider
                // only if it's a callback which was passed by the
                // provider
                if (url.startsWith(oauthCallbackURL)) {
                  Uri uri = Uri.parse(url);
                  completeVerify(uri);
                  return true;
                }
                return false;
              }
            });
      }

      // we should append additional param forcing login/pass request, otherwise app will be loaded
      // with previous account
      // decision based on https://dev.twitter.com/oauth/reference/get/oauth/authorize
      String url = getIntent().getStringExtra("url") + "&force_login=true";
      webView.loadUrlOnUiThread(url);
      webView.show(this);
    }
        /**
         * Called when OAuth authentication has been finalized and an Access Token and Access Token
         * Secret have been provided
         *
         * @param accessToken The access token to use to do REST calls
         */
        @Override
        public void gotOAuthAccessToken(AccessToken accessToken) {
          SoomlaUtils.LogDebug(TAG, "login/onComplete");

          twitter.setOAuthAccessToken(accessToken);

          // Keep in storage for logging in without web-authentication
          KeyValueStorage.setValue(
              getTwitterStorageKey(TWITTER_OAUTH_TOKEN), accessToken.getToken());
          KeyValueStorage.setValue(
              getTwitterStorageKey(TWITTER_OAUTH_SECRET), accessToken.getTokenSecret());

          // Keep screen name since Twitter4J does not have it when
          // logging in using authenticated tokens
          KeyValueStorage.setValue(
              getTwitterStorageKey(TWITTER_SCREEN_NAME), accessToken.getScreenName());

          twitterScreenName = accessToken.getScreenName();

          RefLoginListener.success(RefProvider);

          clearListener(ACTION_LOGIN);
        }
  /** {@inheritDoc} */
  @Override
  public void login(
      final Activity parentActivity, final AuthCallbacks.LoginListener loginListener) {
    if (!isInitialized) {
      SoomlaUtils.LogError(
          TAG, "Consumer key and secret were not defined, please provide them in initialization");
      return;
    }

    SoomlaUtils.LogDebug(TAG, "login");
    WeakRefParentActivity = new WeakReference<Activity>(parentActivity);

    RefProvider = getProvider();
    RefLoginListener = loginListener;

    preformingAction = ACTION_LOGIN;

    mainRequestToken = null;
    twitter.setOAuthAccessToken(null);

    // Try logging in using store credentials
    String oauthToken = KeyValueStorage.getValue(getTwitterStorageKey(TWITTER_OAUTH_TOKEN));
    String oauthTokenSecret = KeyValueStorage.getValue(getTwitterStorageKey(TWITTER_OAUTH_SECRET));
    if (!TextUtils.isEmpty(oauthToken) && !TextUtils.isEmpty(oauthTokenSecret)) {
      twitter.setOAuthAccessToken(new AccessToken(oauthToken, oauthTokenSecret));
      twitterScreenName = KeyValueStorage.getValue(getTwitterStorageKey(TWITTER_SCREEN_NAME));

      loginListener.success(RefProvider);

      clearListener(ACTION_LOGIN);
    } else {
      // If no stored credentials start login process by requesting
      // a request token
      twitter.getOAuthRequestTokenAsync(oauthCallbackURL);
    }
  }
  /** {@inheritDoc} */
  @Override
  public void uploadImage(
      String message,
      String filePath,
      final SocialCallbacks.SocialActionListener socialActionListener) {
    if (!isInitialized) {
      return;
    }

    SoomlaUtils.LogDebug(TAG, "uploadImage");

    RefProvider = getProvider();
    RefSocialActionListener = socialActionListener;

    preformingAction = ACTION_UPLOAD_IMAGE;

    try {
      StatusUpdate updateImage = new StatusUpdate(message);
      updateImage.media(new File(filePath));
      twitter.updateStatus(updateImage);
    } catch (Exception e) {
      failListener(ACTION_UPLOAD_IMAGE, e.getMessage());
    }
  }
  /** {@inheritDoc} */
  @Override
  public void getFeed(Boolean fromStart, final SocialCallbacks.FeedListener feedListener) {
    if (!isInitialized) {
      return;
    }

    SoomlaUtils.LogDebug(TAG, "getFeed");

    RefProvider = getProvider();
    RefFeedListener = feedListener;

    preformingAction = ACTION_GET_FEED;

    try {
      if (fromStart) {
        this.lastFeedCursor = 1;
      }

      Paging paging = new Paging(this.lastFeedCursor, PAGE_SIZE);
      twitter.getUserTimeline(paging);
    } catch (Exception e) {
      failListener(ACTION_GET_FEED, e.getMessage());
    }
  }
 /** {@inheritDoc} */
 @Override
 protected void onResume() {
   super.onResume();
   SoomlaUtils.LogDebug(TAG, "onResume");
 }
    /** {@inheritDoc} */
    @Override
    protected void onStop() {
      super.onStop();

      SoomlaUtils.LogDebug(TAG, "onStop");
    }
 public static void initialize() {
   SoomlaUtils.LogDebug("SOOMLA Unity SoomlaEventHandler", "Initializing SoomlaEventHandler ...");
   mLocalEventHandler = new SoomlaEventHandler();
 }