code stringlengths 3 1.18M | language stringclasses 1
value |
|---|---|
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Settings;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class SettingsParser extends AbstractParser<Settings> {
@Override
public Settings parse(JSONObject json) throws JSONException {
Settings obj = new Settings();
if (json.has("feeds_key")) {
obj.setFeedsKey(json.getString("feeds_key"));
}
if (json.has("get_pings")) {
obj.setGetPings(json.getBoolean("get_pings"));
}
if (json.has("pings")) {
obj.setPings(json.getString("pings"));
}
if (json.has("sendtofacebook")) {
obj.setSendtofacebook(json.getBoolean("sendtofacebook"));
}
if (json.has("sendtotwitter")) {
obj.setSendtotwitter(json.getBoolean("sendtotwitter"));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.CheckinResult;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class CheckinResultParser extends AbstractParser<CheckinResult> {
@Override
public CheckinResult parse(JSONObject json) throws JSONException {
CheckinResult obj = new CheckinResult();
if (json.has("badges")) {
obj.setBadges(
new GroupParser(
new BadgeParser()).parse(json.getJSONArray("badges")));
}
if (json.has("created")) {
obj.setCreated(json.getString("created"));
}
if (json.has("id")) {
obj.setId(json.getString("id"));
}
if (json.has("markup")) {
obj.setMarkup(json.getString("markup"));
}
if (json.has("mayor")) {
obj.setMayor(new MayorParser().parse(json.getJSONObject("mayor")));
}
if (json.has("message")) {
obj.setMessage(json.getString("message"));
}
if (json.has("scores")) {
obj.setScoring(
new GroupParser(
new ScoreParser()).parse(json.getJSONArray("scores")));
}
if (json.has("specials")) {
obj.setSpecials(
new GroupParser(
new SpecialParser()).parse(json.getJSONArray("specials")));
}
if (json.has("venue")) {
obj.setVenue(new VenueParser().parse(json.getJSONObject("venue")));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Mayor;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class MayorParser extends AbstractParser<Mayor> {
@Override
public Mayor parse(JSONObject json) throws JSONException {
Mayor obj = new Mayor();
if (json.has("checkins")) {
obj.setCheckins(json.getString("checkins"));
}
if (json.has("count")) {
obj.setCount(json.getString("count"));
}
if (json.has("message")) {
obj.setMessage(json.getString("message"));
}
if (json.has("type")) {
obj.setType(json.getString("type"));
}
if (json.has("user")) {
obj.setUser(new UserParser().parse(json.getJSONObject("user")));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.FoursquareType;
import com.joelapenna.foursquare.types.Group;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public interface Parser<T extends FoursquareType> {
public abstract T parse(JSONObject json) throws JSONException;
public Group parse(JSONArray array) throws JSONException;
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Response;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date April 28, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class ResponseParser extends AbstractParser<Response> {
@Override
public Response parse(JSONObject json) throws JSONException {
Response response = new Response();
response.setValue(json.getString("response"));
return response;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Tip;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class TipParser extends AbstractParser<Tip> {
@Override
public Tip parse(JSONObject json) throws JSONException {
Tip obj = new Tip();
if (json.has("created")) {
obj.setCreated(json.getString("created"));
}
if (json.has("distance")) {
obj.setDistance(json.getString("distance"));
}
if (json.has("id")) {
obj.setId(json.getString("id"));
}
if (json.has("stats")) {
obj.setStats(new TipParser.StatsParser().parse(json.getJSONObject("stats")));
}
if (json.has("status")) {
obj.setStatus(json.getString("status"));
}
if (json.has("text")) {
obj.setText(json.getString("text"));
}
if (json.has("user")) {
obj.setUser(new UserParser().parse(json.getJSONObject("user")));
}
if (json.has("venue")) {
obj.setVenue(new VenueParser().parse(json.getJSONObject("venue")));
}
return obj;
}
public static class StatsParser extends AbstractParser<Tip.Stats> {
@Override
public Tip.Stats parse(JSONObject json) throws JSONException {
Tip.Stats stats = new Tip.Stats();
if (json.has("donecount")) {
stats.setDoneCount(json.getInt("donecount"));
}
if (json.has("todocount")) {
stats.setTodoCount(json.getInt("todocount"));
}
return stats;
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Score;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class ScoreParser extends AbstractParser<Score> {
@Override
public Score parse(JSONObject json) throws JSONException {
Score obj = new Score();
if (json.has("icon")) {
obj.setIcon(json.getString("icon"));
}
if (json.has("message")) {
obj.setMessage(json.getString("message"));
}
if (json.has("points")) {
obj.setPoints(json.getString("points"));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Rank;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class RankParser extends AbstractParser<Rank> {
@Override
public Rank parse(JSONObject json) throws JSONException {
Rank obj = new Rank();
if (json.has("city")) {
obj.setCity(json.getString("city"));
}
if (json.has("message")) {
obj.setMessage(json.getString("message"));
}
if (json.has("position")) {
obj.setPosition(json.getString("position"));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.City;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class CityParser extends AbstractParser<City> {
@Override
public City parse(JSONObject json) throws JSONException {
City obj = new City();
if (json.has("geolat")) {
obj.setGeolat(json.getString("geolat"));
}
if (json.has("geolong")) {
obj.setGeolong(json.getString("geolong"));
}
if (json.has("id")) {
obj.setId(json.getString("id"));
}
if (json.has("name")) {
obj.setName(json.getString("name"));
}
if (json.has("shortname")) {
obj.setShortname(json.getString("shortname"));
}
if (json.has("timezone")) {
obj.setTimezone(json.getString("timezone"));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Credentials;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class CredentialsParser extends AbstractParser<Credentials> {
@Override
public Credentials parse(JSONObject json) throws JSONException {
Credentials obj = new Credentials();
if (json.has("oauth_token")) {
obj.setOauthToken(json.getString("oauth_token"));
}
if (json.has("oauth_token_secret")) {
obj.setOauthTokenSecret(json.getString("oauth_token_secret"));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Todo;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date September 2, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class TodoParser extends AbstractParser<Todo> {
@Override
public Todo parse(JSONObject json) throws JSONException {
Todo obj = new Todo();
if (json.has("created")) {
obj.setCreated(json.getString("created"));
}
if (json.has("tip")) {
obj.setTip(new TipParser().parse(json.getJSONObject("tip")));
}
if (json.has("todoid")) {
obj.setId(json.getString("todoid"));
}
return obj;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import org.json.JSONArray;
import org.json.JSONException;
import java.util.ArrayList;
import java.util.List;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class StringArrayParser {
public static List<String> parse(JSONArray json) throws JSONException {
List<String> array = new ArrayList<String>();
for (int i = 0, m = json.length(); i < m; i++) {
array.add(json.getString(i));
}
return array;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Special;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class SpecialParser extends AbstractParser<Special> {
@Override
public Special parse(JSONObject json) throws JSONException {
Special obj = new Special();
if (json.has("id")) {
obj.setId(json.getString("id"));
}
if (json.has("message")) {
obj.setMessage(json.getString("message"));
}
if (json.has("type")) {
obj.setType(json.getString("type"));
}
if (json.has("venue")) {
obj.setVenue(new VenueParser().parse(json.getJSONObject("venue")));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.User;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class UserParser extends AbstractParser<User> {
@Override
public User parse(JSONObject json) throws JSONException {
User user = new User();
if (json.has("badges")) {
user.setBadges(
new GroupParser(
new BadgeParser()).parse(json.getJSONArray("badges")));
}
if (json.has("badgecount")) {
user.setBadgeCount(json.getInt("badgecount"));
}
if (json.has("checkin")) {
user.setCheckin(new CheckinParser().parse(json.getJSONObject("checkin")));
}
if (json.has("checkincount")) {
user.setCheckinCount(json.getInt("checkincount"));
}
if (json.has("created")) {
user.setCreated(json.getString("created"));
}
if (json.has("email")) {
user.setEmail(json.getString("email"));
}
if (json.has("facebook")) {
user.setFacebook(json.getString("facebook"));
}
if (json.has("firstname")) {
user.setFirstname(json.getString("firstname"));
}
if (json.has("followercount")) {
user.setFollowerCount(json.getInt("followercount"));
}
if (json.has("friendcount")) {
user.setFriendCount(json.getInt("friendcount"));
}
if (json.has("friendsincommon")) {
user.setFriendsInCommon(
new GroupParser(
new UserParser()).parse(json.getJSONArray("friendsincommon")));
}
if (json.has("friendstatus")) {
user.setFriendstatus(json.getString("friendstatus"));
}
if (json.has("gender")) {
user.setGender(json.getString("gender"));
}
if (json.has("hometown")) {
user.setHometown(json.getString("hometown"));
}
if (json.has("id")) {
user.setId(json.getString("id"));
}
if (json.has("lastname")) {
user.setLastname(json.getString("lastname"));
}
if (json.has("mayor")) {
user.setMayorships(
new GroupParser(
new VenueParser()).parse(json.getJSONArray("mayor")));
}
if (json.has("mayorcount")) {
user.setMayorCount(json.getInt("mayorcount"));
}
if (json.has("phone")) {
user.setPhone(json.getString("phone"));
}
if (json.has("photo")) {
user.setPhoto(json.getString("photo"));
}
if (json.has("settings")) {
user.setSettings(new SettingsParser().parse(json.getJSONObject("settings")));
}
if (json.has("tipcount")) {
user.setTipCount(json.getInt("tipcount"));
}
if (json.has("todocount")) {
user.setTodoCount(json.getInt("todocount"));
}
if (json.has("twitter")) {
user.setTwitter(json.getString("twitter"));
}
if (json.has("types")) {
user.setTypes(new TypesParser().parseAsJSONArray(json.getJSONArray("types")));
}
return user;
}
//@Override
//public String getObjectName() {
// return "user";
//}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Stats;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class StatsParser extends AbstractParser<Stats> {
@Override
public Stats parse(JSONObject json) throws JSONException {
Stats obj = new Stats();
if (json.has("beenhere")) {
obj.setBeenhere(new BeenhereParser().parse(json.getJSONObject("beenhere")));
}
if (json.has("checkins")) {
obj.setCheckins(json.getString("checkins"));
}
if (json.has("herenow")) {
obj.setHereNow(json.getString("herenow"));
}
if (json.has("mayor")) {
obj.setMayor(new MayorParser().parse(json.getJSONObject("mayor")));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.parsers.json.CategoryParser;
import com.joelapenna.foursquare.parsers.json.GroupParser;
import com.joelapenna.foursquare.types.Category;
import com.joelapenna.foursquare.util.IconUtils;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class CategoryParser extends AbstractParser<Category> {
@Override
public Category parse(JSONObject json) throws JSONException {
Category obj = new Category();
if (json.has("id")) {
obj.setId(json.getString("id"));
}
if (json.has("fullpathname")) {
obj.setFullPathName(json.getString("fullpathname"));
}
if (json.has("nodename")) {
obj.setNodeName(json.getString("nodename"));
}
if (json.has("iconurl")) {
// TODO: Remove this once api v2 allows icon request.
String iconUrl = json.getString("iconurl");
if (IconUtils.get().getRequestHighDensityIcons()) {
iconUrl = iconUrl.replace(".png", "_64.png");
}
obj.setIconUrl(iconUrl);
}
if (json.has("categories")) {
obj.setChildCategories(
new GroupParser(
new CategoryParser()).parse(json.getJSONArray("categories")));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Types;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class TypesParser extends AbstractParser<Types> {
@Override
public Types parse(JSONObject json) throws JSONException {
Types obj = new Types();
if (json.has("type")) {
obj.add(json.getString("type"));
}
return obj;
}
public Types parseAsJSONArray(JSONArray array) throws JSONException {
Types obj = new Types();
for (int i = 0, m = array.length(); i < m; i++) {
obj.add(array.getString(i));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Data;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class DataParser extends AbstractParser<Data> {
@Override
public Data parse(JSONObject json) throws JSONException {
Data obj = new Data();
if (json.has("cityid")) {
obj.setCityid(json.getString("cityid"));
}
if (json.has("message")) {
obj.setMessage(json.getString("message"));
}
if (json.has("status")) {
obj.setStatus("1".equals(json.getString("status")));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Badge;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class BadgeParser extends AbstractParser<Badge> {
@Override
public Badge parse(JSONObject json) throws JSONException {
Badge obj = new Badge();
if (json.has("description")) {
obj.setDescription(json.getString("description"));
}
if (json.has("icon")) {
obj.setIcon(json.getString("icon"));
}
if (json.has("id")) {
obj.setId(json.getString("id"));
}
if (json.has("name")) {
obj.setName(json.getString("name"));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Beenhere;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class BeenhereParser extends AbstractParser<Beenhere> {
@Override
public Beenhere parse(JSONObject json) throws JSONException {
Beenhere obj = new Beenhere();
if (json.has("friends")) {
obj.setFriends(json.getBoolean("friends"));
}
if (json.has("me")) {
obj.setMe(json.getBoolean("me"));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.FoursquareType;
import com.joelapenna.foursquare.types.Group;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.Iterator;
import java.util.logging.Level;
/**
* Reference:
* http://www.json.org/javadoc/org/json/JSONObject.html
* http://www.json.org/javadoc/org/json/JSONArray.html
*
* @author Mark Wyszomierski (markww@gmail.com)
* @param <T>
*/
public class GroupParser extends AbstractParser<Group> {
private Parser<? extends FoursquareType> mSubParser;
public GroupParser(Parser<? extends FoursquareType> subParser) {
mSubParser = subParser;
}
/**
* When we encounter a JSONObject in a GroupParser, we expect one attribute
* named 'type', and then another JSONArray attribute.
*/
public Group<FoursquareType> parse(JSONObject json) throws JSONException {
Group<FoursquareType> group = new Group<FoursquareType>();
Iterator<String> it = (Iterator<String>)json.keys();
while (it.hasNext()) {
String key = it.next();
if (key.equals("type")) {
group.setType(json.getString(key));
} else {
Object obj = json.get(key);
if (obj instanceof JSONArray) {
parse(group, (JSONArray)obj);
} else {
throw new JSONException("Could not parse data.");
}
}
}
return group;
}
/**
* Here we are getting a straight JSONArray and do not expect the 'type' attribute.
*/
@Override
public Group parse(JSONArray array) throws JSONException {
Group<FoursquareType> group = new Group<FoursquareType>();
parse(group, array);
return group;
}
private void parse(Group group, JSONArray array) throws JSONException {
for (int i = 0, m = array.length(); i < m; i++) {
Object element = array.get(i);
FoursquareType item = null;
if (element instanceof JSONArray) {
item = mSubParser.parse((JSONArray)element);
} else {
item = mSubParser.parse((JSONObject)element);
}
group.add(item);
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.types.Checkin;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class CheckinParser extends AbstractParser<Checkin> {
@Override
public Checkin parse(JSONObject json) throws JSONException {
Checkin obj = new Checkin();
if (json.has("created")) {
obj.setCreated(json.getString("created"));
}
if (json.has("display")) {
obj.setDisplay(json.getString("display"));
}
if (json.has("distance")) {
obj.setDistance(json.getString("distance"));
}
if (json.has("id")) {
obj.setId(json.getString("id"));
}
if (json.has("ismayor")) {
obj.setIsmayor(json.getBoolean("ismayor"));
}
if (json.has("ping")) {
obj.setPing(json.getBoolean("ping"));
}
if (json.has("shout")) {
obj.setShout(json.getString("shout"));
}
if (json.has("user")) {
obj.setUser(new UserParser().parse(json.getJSONObject("user")));
}
if (json.has("venue")) {
obj.setVenue(new VenueParser().parse(json.getJSONObject("venue")));
}
return obj;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.parsers.json;
import com.joelapenna.foursquare.parsers.json.Parser;
import com.joelapenna.foursquare.types.FoursquareType;
import com.joelapenna.foursquare.types.Group;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
/**
* @date July 13, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public abstract class AbstractParser<T extends FoursquareType> implements Parser<T> {
/**
* All derived parsers must implement parsing a JSONObject instance of themselves.
*/
public abstract T parse(JSONObject json) throws JSONException;
/**
* Only the GroupParser needs to implement this.
*/
public Group parse(JSONArray array) throws JSONException {
throw new JSONException("Unexpected JSONArray parse type encountered.");
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.util;
import android.os.Parcel;
/**
* @date March 25, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class ParcelUtils {
public static void writeStringToParcel(Parcel out, String str) {
if (str != null) {
out.writeInt(1);
out.writeString(str);
} else {
out.writeInt(0);
}
}
public static String readStringFromParcel(Parcel in) {
int flag = in.readInt();
if (flag == 1) {
return in.readString();
} else {
return null;
}
}
} | Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquare.util;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class MayorUtils {
public static final String TYPE_NOCHANGE = "nochange";
public static final String TYPE_NEW = "new";
public static final String TYPE_STOLEN = "stolen";
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquare.util;
import com.joelapenna.foursquare.types.Venue;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class VenueUtils {
public static final boolean isValid(Venue venue) {
return !(venue == null || venue.getId() == null || venue.getId().length() == 0);
}
public static final boolean hasValidLocation(Venue venue) {
boolean valid = false;
if (venue != null) {
String geoLat = venue.getGeolat();
String geoLong = venue.getGeolong();
if (!(geoLat == null || geoLat.length() == 0 || geoLong == null || geoLong.length() == 0)) {
if (geoLat != "0" || geoLong != "0") {
valid = true;
}
}
}
return valid;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.util;
/**
* This is not ideal.
*
* @date July 1, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class IconUtils {
private static IconUtils mInstance;
private boolean mRequestHighDensityIcons;
private IconUtils() {
mRequestHighDensityIcons = false;
}
public static IconUtils get() {
if (mInstance == null) {
mInstance = new IconUtils();
}
return mInstance;
}
public boolean getRequestHighDensityIcons() {
return mRequestHighDensityIcons;
}
public void setRequestHighDensityIcons(boolean requestHighDensityIcons) {
mRequestHighDensityIcons = requestHighDensityIcons;
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.util;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareCredentialsException;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquare.error.FoursquareParseException;
import com.joelapenna.foursquare.parsers.json.Parser;
import com.joelapenna.foursquare.parsers.json.TipParser;
import com.joelapenna.foursquare.types.FoursquareType;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.IOException;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
public class JSONUtils {
private static final boolean DEBUG = Foursquare.DEBUG;
private static final Logger LOG = Logger.getLogger(TipParser.class.getCanonicalName());
/**
* Takes a parser, a json string, and returns a foursquare type.
*/
public static FoursquareType consume(Parser<? extends FoursquareType> parser, String content)
throws FoursquareCredentialsException, FoursquareParseException, FoursquareException, IOException {
if (DEBUG) {
LOG.log(Level.FINE, "http response: " + content);
}
try {
// The v1 API returns the response raw with no wrapper. Depending on the
// type of API call, the content might be a JSONObject or a JSONArray.
// Since JSONArray does not derive from JSONObject, we need to check for
// either of these cases to parse correctly.
JSONObject json = new JSONObject(content);
Iterator<String> it = (Iterator<String>)json.keys();
if (it.hasNext()) {
String key = (String)it.next();
if (key.equals("error")) {
throw new FoursquareException(json.getString(key));
} else {
Object obj = json.get(key);
if (obj instanceof JSONArray) {
return parser.parse((JSONArray)obj);
} else {
return parser.parse((JSONObject)obj);
}
}
} else {
throw new FoursquareException("Error parsing JSON response, object had no single child key.");
}
} catch (JSONException ex) {
throw new FoursquareException("Error parsing JSON response: " + ex.getMessage());
}
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.types;
/**
* @date 2010-05-05
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class FriendInvitesResult implements FoursquareType {
/**
* Users that are in our contact book by email or phone, are already on foursquare,
* but are not our friends.
*/
private Group<User> mContactsOnFoursquare;
/**
* Users not on foursquare, but in our contact book by email or phone. These are
* users we have not already sent an email invite to.
*/
private Emails mContactEmailsNotOnFoursquare;
/**
* A list of email addresses we've already sent email invites to.
*/
private Emails mContactEmailsNotOnFoursquareAlreadyInvited;
public FriendInvitesResult() {
mContactsOnFoursquare = new Group<User>();
mContactEmailsNotOnFoursquare = new Emails();
mContactEmailsNotOnFoursquareAlreadyInvited = new Emails();
}
public Group<User> getContactsOnFoursquare() {
return mContactsOnFoursquare;
}
public void setContactsOnFoursquare(Group<User> contactsOnFoursquare) {
mContactsOnFoursquare = contactsOnFoursquare;
}
public Emails getContactEmailsNotOnFoursquare() {
return mContactEmailsNotOnFoursquare;
}
public void setContactEmailsOnNotOnFoursquare(Emails emails) {
mContactEmailsNotOnFoursquare = emails;
}
public Emails getContactEmailsNotOnFoursquareAlreadyInvited() {
return mContactEmailsNotOnFoursquareAlreadyInvited;
}
public void setContactEmailsOnNotOnFoursquareAlreadyInvited(Emails emails) {
mContactEmailsNotOnFoursquareAlreadyInvited = emails;
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquare.types;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public interface FoursquareType {
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.types;
import java.util.ArrayList;
/**
* @date 2010-05-05
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class Emails extends ArrayList<String> implements FoursquareType {
private static final long serialVersionUID = 1L;
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.types;
import com.joelapenna.foursquare.util.ParcelUtils;
import android.os.Parcel;
import android.os.Parcelable;
/**
* @date September 2, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class Todo implements FoursquareType, Parcelable {
private String mCreated;
private String mId;
private Tip mTip;
public Todo() {
}
private Todo(Parcel in) {
mCreated = ParcelUtils.readStringFromParcel(in);
mId = ParcelUtils.readStringFromParcel(in);
if (in.readInt() == 1) {
mTip = in.readParcelable(Tip.class.getClassLoader());
}
}
public static final Parcelable.Creator<Todo> CREATOR = new Parcelable.Creator<Todo>() {
public Todo createFromParcel(Parcel in) {
return new Todo(in);
}
@Override
public Todo[] newArray(int size) {
return new Todo[size];
}
};
public String getCreated() {
return mCreated;
}
public void setCreated(String created) {
mCreated = created;
}
public String getId() {
return mId;
}
public void setId(String id) {
mId = id;
}
public Tip getTip() {
return mTip;
}
public void setTip(Tip tip) {
mTip = tip;
}
@Override
public void writeToParcel(Parcel out, int flags) {
ParcelUtils.writeStringToParcel(out, mCreated);
ParcelUtils.writeStringToParcel(out, mId);
if (mTip != null) {
out.writeInt(1);
out.writeParcelable(mTip, flags);
} else {
out.writeInt(0);
}
}
@Override
public int describeContents() {
return 0;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.types;
/**
* @date April 28, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class Response implements FoursquareType {
private String mValue;
public Response() {
}
public String getValue() {
return mValue;
}
public void setValue(String value) {
mValue = value;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquare.types;
import com.joelapenna.foursquare.util.ParcelUtils;
import android.os.Parcel;
import android.os.Parcelable;
/**
* @date March 6, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class Category implements FoursquareType, Parcelable {
/** The category's id. */
private String mId;
/** Full category path name, like Nightlife:Bars. */
private String mFullPathName;
/** Simple name of the category. */
private String mNodeName;
/** Url of the icon associated with this category. */
private String mIconUrl;
/** Categories can be nested within one another too. */
private Group<Category> mChildCategories;
public Category() {
mChildCategories = new Group<Category>();
}
private Category(Parcel in) {
mChildCategories = new Group<Category>();
mId = ParcelUtils.readStringFromParcel(in);
mFullPathName = ParcelUtils.readStringFromParcel(in);
mNodeName = ParcelUtils.readStringFromParcel(in);
mIconUrl = ParcelUtils.readStringFromParcel(in);
int numCategories = in.readInt();
for (int i = 0; i < numCategories; i++) {
Category category = in.readParcelable(Category.class.getClassLoader());
mChildCategories.add(category);
}
}
public static final Parcelable.Creator<Category> CREATOR = new Parcelable.Creator<Category>() {
public Category createFromParcel(Parcel in) {
return new Category(in);
}
@Override
public Category[] newArray(int size) {
return new Category[size];
}
};
public String getId() {
return mId;
}
public void setId(String id) {
mId = id;
}
public String getFullPathName() {
return mFullPathName;
}
public void setFullPathName(String fullPathName) {
mFullPathName = fullPathName;
}
public String getNodeName() {
return mNodeName;
}
public void setNodeName(String nodeName) {
mNodeName = nodeName;
}
public String getIconUrl() {
return mIconUrl;
}
public void setIconUrl(String iconUrl) {
mIconUrl = iconUrl;
}
public Group<Category> getChildCategories() {
return mChildCategories;
}
public void setChildCategories(Group<Category> categories) {
mChildCategories = categories;
}
@Override
public void writeToParcel(Parcel out, int flags) {
ParcelUtils.writeStringToParcel(out, mId);
ParcelUtils.writeStringToParcel(out, mFullPathName);
ParcelUtils.writeStringToParcel(out, mNodeName);
ParcelUtils.writeStringToParcel(out, mIconUrl);
out.writeInt(mChildCategories.size());
for (Category it : mChildCategories) {
out.writeParcelable(it, flags);
}
}
@Override
public int describeContents() {
return 0;
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquare.types;
import java.util.ArrayList;
import java.util.List;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class Tags extends ArrayList<String> implements FoursquareType {
private static final long serialVersionUID = 1L;
public Tags() {
super();
}
public Tags(List<String> values) {
super();
addAll(values);
}
} | Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquare.types;
import java.util.ArrayList;
import java.util.Collection;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class Group<T extends FoursquareType> extends ArrayList<T> implements FoursquareType {
private static final long serialVersionUID = 1L;
private String mType;
public Group() {
super();
}
public Group(Collection<T> collection) {
super(collection);
}
public void setType(String type) {
mType = type;
}
public String getType() {
return mType;
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquare.types;
import java.util.ArrayList;
/**
* @date April 14, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class Types extends ArrayList<String> implements FoursquareType {
private static final long serialVersionUID = 1L;
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.app;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Checkin;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.Foursquared;
import com.joelapenna.foursquared.FriendsActivity;
import com.joelapenna.foursquared.MainActivity;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.preferences.Preferences;
import com.joelapenna.foursquared.util.StringFormatters;
import android.app.AlarmManager;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.location.Location;
import android.location.LocationManager;
import android.os.SystemClock;
import android.preference.PreferenceManager;
import android.text.TextUtils;
import android.util.Log;
import android.widget.RemoteViews;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* This service will run every N minutes (specified by the user in settings). An alarm
* handles running the service.
*
* When the service runs, we call /checkins. From the list of checkins, we cut down the
* list of relevant checkins as follows:
* <ul>
* <li>Not one of our own checkins.</li>
* <li>We haven't turned pings off for the user. This can be toggled on/off in the
* UserDetailsActivity activity, per user.</li>
* <li>The checkin is younger than the last time we ran this service.</li>
* </ul>
*
* Note that the server might override the pings attribute to 'off' for certain checkins,
* usually if the checkin is far away from our current location.
*
* Pings will not be cleared from the notification bar until a subsequent run can
* generate at least one new ping. A new batch of pings will clear all
* previous pings so as to not clutter the notification bar.
*
* @date May 21, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class PingsService extends WakefulIntentService {
public static final String TAG = "PingsService";
private static final boolean DEBUG = false;
public static final int NOTIFICATION_ID_CHECKINS = 15;
public PingsService() {
super("PingsService");
}
@Override
public void onCreate() {
super.onCreate();
}
@Override
protected void doWakefulWork(Intent intent) {
Log.i(TAG, "Foursquare pings service running...");
// The user must have logged in once previously for this to work,
// and not leave the app in a logged-out state.
Foursquared foursquared = (Foursquared) getApplication();
Foursquare foursquare = foursquared.getFoursquare();
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
if (!foursquared.isReady()) {
Log.i(TAG, "User not logged in, cannot proceed.");
return;
}
// Before running, make sure the user still wants pings on.
// For example, the user could have turned pings on from
// this device, but then turned it off on a second device. This
// service would continue running then, continuing to notify the
// user.
if (!checkUserStillWantsPings(foursquared.getUserId(), foursquare)) {
// Turn off locally.
Log.i(TAG, "Pings have been turned off for user, cancelling service.");
prefs.edit().putBoolean(Preferences.PREFERENCE_PINGS, false).commit();
cancelPings(this);
return;
}
// Get the users current location and then request nearby checkins.
Group<Checkin> checkins = null;
Location location = getLastGeolocation();
if (location != null) {
try {
checkins = foursquare.checkins(
LocationUtils.createFoursquareLocation(location));
} catch (Exception ex) {
Log.e(TAG, "Error getting checkins in pings service.", ex);
}
} else {
Log.e(TAG, "Could not find location in pings service, cannot proceed.");
}
if (checkins != null) {
Log.i(TAG, "Checking " + checkins.size() + " checkins for pings.");
// Don't accept any checkins that are older than the last time we ran.
long lastRunTime = prefs.getLong(
Preferences.PREFERENCE_PINGS_SERVICE_LAST_RUN_TIME, System.currentTimeMillis());
Date dateLast = new Date(lastRunTime);
Log.i(TAG, "Last service run time: " + dateLast.toLocaleString() + " (" + lastRunTime + ").");
// Now build the list of 'new' checkins.
List<Checkin> newCheckins = new ArrayList<Checkin>();
for (Checkin it : checkins) {
if (DEBUG) Log.d(TAG, "Checking checkin of " + it.getUser().getFirstname());
// Ignore ourselves. The server should handle this by setting the pings flag off but..
if (it.getUser() != null && it.getUser().getId().equals(foursquared.getUserId())) {
if (DEBUG) Log.d(TAG, " Ignoring checkin of ourselves.");
continue;
}
// Check that our user wanted to see pings from this user.
if (!it.getPing()) {
if (DEBUG) Log.d(TAG, " Pings are off for this user.");
continue;
}
// If it's an 'off the grid' checkin, ignore.
if (it.getVenue() == null && it.getShout() == null) {
if (DEBUG) Log.d(TAG, " Checkin is off the grid, ignoring.");
continue;
}
// Check against date times.
try {
Date dateCheckin = StringFormatters.DATE_FORMAT.parse(it.getCreated());
if (DEBUG) {
Log.d(TAG, " Comaring date times for checkin.");
Log.d(TAG, " Last run time: " + dateLast.toLocaleString());
Log.d(TAG, " Checkin time: " + dateCheckin.toLocaleString());
}
if (dateCheckin.after(dateLast)) {
if (DEBUG) Log.d(TAG, " Checkin is younger than our last run time, passes all tests!!");
newCheckins.add(it);
} else {
if (DEBUG) Log.d(TAG, " Checkin is older than last run time.");
}
} catch (ParseException ex) {
if (DEBUG) Log.e(TAG, " Error parsing checkin timestamp: " + it.getCreated(), ex);
}
}
Log.i(TAG, "Found " + newCheckins.size() + " new checkins.");
notifyUser(newCheckins);
} else {
// Checkins were null, so don't record this as the last run time in order to try
// fetching checkins we may have missed on the next run.
// Thanks to logan.johnson@gmail.com for the fix.
Log.i(TAG, "Checkins were null, won't update last run timestamp.");
return;
}
// Record this as the last time we ran.
prefs.edit().putLong(
Preferences.PREFERENCE_PINGS_SERVICE_LAST_RUN_TIME, System.currentTimeMillis()).commit();
}
private Location getLastGeolocation() {
LocationManager manager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
List<String> providers = manager.getAllProviders();
Location bestLocation = null;
for (String it : providers) {
Location location = manager.getLastKnownLocation(it);
if (location != null) {
if (bestLocation == null || location.getAccuracy() < bestLocation.getAccuracy()) {
bestLocation = location;
}
}
}
return bestLocation;
}
private void notifyUser(List<Checkin> newCheckins) {
// If we have no new checkins to show, nothing to do. We would also be leaving the
// previous batch of pings alive (if any) which is ok.
if (newCheckins.size() < 1) {
return;
}
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
// Clear all previous pings notifications before showing new ones.
NotificationManager mgr = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
mgr.cancelAll();
// We'll only ever show a single entry, so we collapse data depending on how many
// new checkins we received on this refresh.
RemoteViews contentView = new RemoteViews(getPackageName(), R.layout.pings_list_item);
if (newCheckins.size() == 1) {
// A single checkin, show full checkin preview.
Checkin checkin = newCheckins.get(0);
String checkinMsgLine1 = StringFormatters.getCheckinMessageLine1(checkin, true);
String checkinMsgLine2 = StringFormatters.getCheckinMessageLine2(checkin);
String checkinMsgLine3 = StringFormatters.getCheckinMessageLine3(checkin);
contentView.setTextViewText(R.id.text1, checkinMsgLine1);
if (!TextUtils.isEmpty(checkinMsgLine2)) {
contentView.setTextViewText(R.id.text2, checkinMsgLine2);
contentView.setTextViewText(R.id.text3, checkinMsgLine3);
} else {
contentView.setTextViewText(R.id.text2, checkinMsgLine3);
}
} else {
// More than one new checkin, collapse them.
String checkinMsgLine1 = newCheckins.size() + " new Foursquare checkins!";
StringBuilder sbCheckinMsgLine2 = new StringBuilder(1024);
for (Checkin it : newCheckins) {
sbCheckinMsgLine2.append(StringFormatters.getUserAbbreviatedName(it.getUser()));
sbCheckinMsgLine2.append(", ");
}
if (sbCheckinMsgLine2.length() > 0) {
sbCheckinMsgLine2.delete(sbCheckinMsgLine2.length()-2, sbCheckinMsgLine2.length());
}
String checkinMsgLine3 = "at " + StringFormatters.DATE_FORMAT_TODAY.format(new Date());
contentView.setTextViewText(R.id.text1, checkinMsgLine1);
contentView.setTextViewText(R.id.text2, sbCheckinMsgLine2.toString());
contentView.setTextViewText(R.id.text3, checkinMsgLine3);
}
PendingIntent pi = PendingIntent.getActivity(this, 0, new Intent(this, FriendsActivity.class), 0);
Notification notification = new Notification(
R.drawable.notification_icon,
"Foursquare Checkin",
System.currentTimeMillis());
notification.contentView = contentView;
notification.contentIntent = pi;
notification.flags |= Notification.FLAG_AUTO_CANCEL;
if (prefs.getBoolean(Preferences.PREFERENCE_PINGS_VIBRATE, false)) {
notification.defaults |= Notification.DEFAULT_VIBRATE;
}
if (newCheckins.size() > 1) {
notification.number = newCheckins.size();
}
mgr.notify(NOTIFICATION_ID_CHECKINS, notification);
}
private boolean checkUserStillWantsPings(String userId, Foursquare foursquare) {
try {
User user = foursquare.user(userId, false, false, false, null);
if (user != null) {
return user.getSettings().getPings().equals("on");
}
} catch (Exception ex) {
// Assume they still want it on.
}
return true;
}
public static void setupPings(Context context) {
// If the user has pings on, set an alarm every N minutes, where N is their
// requested refresh rate. We default to 30 if some problem reading set interval.
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
if (prefs.getBoolean(Preferences.PREFERENCE_PINGS, false)) {
int refreshRateInMinutes = getRefreshIntervalInMinutes(prefs);
if (DEBUG) {
Log.d(TAG, "User has pings on, attempting to setup alarm with interval: "
+ refreshRateInMinutes + "..");
}
// We want to mark this as the last run time so we don't get any notifications
// before the service is started.
prefs.edit().putLong(
Preferences.PREFERENCE_PINGS_SERVICE_LAST_RUN_TIME, System.currentTimeMillis()).commit();
// Schedule the alarm.
AlarmManager mgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
mgr.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
SystemClock.elapsedRealtime() + (refreshRateInMinutes * 60 * 1000),
refreshRateInMinutes * 60 * 1000,
makePendingIntentAlarm(context));
}
}
public static void cancelPings(Context context) {
AlarmManager mgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
mgr.cancel(makePendingIntentAlarm(context));
}
private static PendingIntent makePendingIntentAlarm(Context context) {
return PendingIntent.getBroadcast(context, 0, new Intent(context, PingsOnAlarmReceiver.class), 0);
}
public static void clearAllNotifications(Context context) {
NotificationManager mgr = (NotificationManager)context.getSystemService(NOTIFICATION_SERVICE);
mgr.cancelAll();
}
public static void generatePingsTest(Context context) {
Intent intent = new Intent(context, MainActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
PendingIntent pi = PendingIntent.getActivity(context, 0, intent, 0);
NotificationManager mgr = (NotificationManager)context.getSystemService(NOTIFICATION_SERVICE);
RemoteViews contentView = new RemoteViews(context.getPackageName(), R.layout.pings_list_item);
contentView.setTextViewText(R.id.text1, "Ping title line");
contentView.setTextViewText(R.id.text2, "Ping message line 2");
contentView.setTextViewText(R.id.text3, "Ping message line 3");
Notification notification = new Notification(
R.drawable.notification_icon,
"Foursquare Checkin",
System.currentTimeMillis());
notification.contentView = contentView;
notification.contentIntent = pi;
notification.defaults |= Notification.DEFAULT_VIBRATE;
mgr.notify(-1, notification);
}
private static int getRefreshIntervalInMinutes(SharedPreferences prefs) {
int refreshRateInMinutes = 30;
try {
refreshRateInMinutes = Integer.parseInt(prefs.getString(
Preferences.PREFERENCE_PINGS_INTERVAL, String.valueOf(refreshRateInMinutes)));
} catch (NumberFormatException ex) {
Log.e(TAG, "Error parsing pings interval time, defaulting to: " + refreshRateInMinutes);
}
return refreshRateInMinutes;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
* Portions Copyright (c) 2008-2010 CommonsWare, LLC
*/
package com.joelapenna.foursquared.app;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
/**
* This is based off the chapter 13 sample in Advanced Android Development, by Mark Murphy.
*
* @date May 21, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class PingsOnAlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
WakefulIntentService.acquireStaticLock(context);
context.startService(new Intent(context, PingsService.class));
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared.app;
import com.joelapenna.foursquare.types.Checkin;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquared.Foursquared;
import com.joelapenna.foursquared.FoursquaredSettings;
import com.joelapenna.foursquared.appwidget.FriendsAppWidgetProvider;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.util.Comparators;
import android.app.IntentService;
import android.appwidget.AppWidgetManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.util.Log;
import java.util.Collections;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class FoursquaredService extends IntentService {
private static final String TAG = "FoursquaredService";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
public FoursquaredService() {
super("FoursquaredService");
}
/**
* Handles various intents, appwidget state changes for starters.
*
* {@inheritDoc}
*/
@Override
public void onHandleIntent(Intent intent) {
if (DEBUG) Log.d(TAG, "onHandleIntent: " + intent.toString());
if (AppWidgetManager.ACTION_APPWIDGET_UPDATE.equals(intent.getAction())) {
updateWidgets();
}
}
private void updateWidgets() {
if (DEBUG) Log.d(TAG, "updateWidgets");
Group<Checkin> checkins = null;
Foursquared foursquared = ((Foursquared) getApplication());
if (foursquared.isReady()) {
if (DEBUG) Log.d(TAG, "User settings are ready, starting normal widget update.");
try {
checkins = foursquared.getFoursquare().checkins(
LocationUtils.createFoursquareLocation(foursquared.getLastKnownLocation()));
} catch (Exception e) {
if (DEBUG) Log.d(TAG, "Exception: Skipping widget update.", e);
return;
}
Collections.sort(checkins, Comparators.getCheckinRecencyComparator());
// Request the user photos for the checkins... At the moment, this
// is async. It is likely this means that the first update of the widget will never
// show user photos as the photos will still be downloading when the getInputStream
// call is made in SpecialDealsAppWidgetProvider.
for (int i = 0; i < checkins.size(); i++) {
Uri photoUri = Uri.parse((checkins.get(i)).getUser().getPhoto());
if (!foursquared.getRemoteResourceManager().exists(photoUri)) {
foursquared.getRemoteResourceManager().request(photoUri);
}
}
}
AppWidgetManager am = AppWidgetManager.getInstance(this);
int[] appWidgetIds = am.getAppWidgetIds(new ComponentName(this,
FriendsAppWidgetProvider.class));
for (int i = 0; i < appWidgetIds.length; i++) {
FriendsAppWidgetProvider.updateAppWidget((Context) this, foursquared
.getRemoteResourceManager(), am, appWidgetIds[i], checkins);
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.app;
import com.joelapenna.foursquared.R;
import android.app.ListActivity;
import android.os.Bundle;
import android.view.View;
import android.view.Window;
import android.widget.LinearLayout;
/**
* This is pretty much a direct copy of LoadableListActivity. It just gives the caller
* a chance to set their own view for the empty state. This is used by FriendsActivity
* to show a button like 'Find some friends!' when the list is empty (in the case that
* they are a new user and have no friends initially).
*
* By default, loadable_list_activity_with_view is used as the intial empty view with
* a progress bar and textview description. The owner can then call setEmptyView()
* with their own view to show if there are no results.
*
* @date April 25, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class LoadableListActivityWithView extends ListActivity {
private LinearLayout mLayoutHeader;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.loadable_list_activity_with_view);
mLayoutHeader = (LinearLayout)findViewById(R.id.header);
getListView().setDividerHeight(0);
}
public void setEmptyView(View view) {
LinearLayout parent = (LinearLayout)findViewById(R.id.loadableListHolder);
parent.getChildAt(0).setVisibility(View.GONE);
if (parent.getChildCount() > 1) {
parent.removeViewAt(1);
}
parent.addView(view);
}
public void setLoadingView() {
LinearLayout parent = (LinearLayout)findViewById(R.id.loadableListHolder);
if (parent.getChildCount() > 1) {
parent.removeViewAt(1);
}
parent.getChildAt(0).setVisibility(View.VISIBLE);
}
public int getNoSearchResultsStringId() {
return R.string.no_search_results;
}
public LinearLayout getHeaderLayout() {
return mLayoutHeader;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.app;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.widget.SegmentedButton;
import android.app.ListActivity;
import android.os.Bundle;
import android.view.View;
import android.view.Window;
import android.widget.LinearLayout;
/**
* This is pretty much a direct copy of LoadableListActivity. It just gives the caller
* a chance to set their own view for the empty state. This is used by FriendsActivity
* to show a button like 'Find some friends!' when the list is empty (in the case that
* they are a new user and have no friends initially).
*
* By default, loadable_list_activity_with_view is used as the intial empty view with
* a progress bar and textview description. The owner can then call setEmptyView()
* with their own view to show if there are no results.
*
* @date April 25, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class LoadableListActivityWithViewAndHeader extends ListActivity {
private LinearLayout mLayoutHeader;
private SegmentedButton mHeaderButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.loadable_list_activity_with_view_and_header);
mLayoutHeader = (LinearLayout)findViewById(R.id.header);
mHeaderButton = (SegmentedButton)findViewById(R.id.segmented);
getListView().setDividerHeight(0);
}
public void setEmptyView(View view) {
LinearLayout parent = (LinearLayout)findViewById(R.id.loadableListHolder);
parent.getChildAt(0).setVisibility(View.GONE);
if (parent.getChildCount() > 1) {
parent.removeViewAt(1);
}
parent.addView(view);
}
public void setLoadingView() {
LinearLayout parent = (LinearLayout)findViewById(R.id.loadableListHolder);
if (parent.getChildCount() > 1) {
parent.removeViewAt(1);
}
parent.getChildAt(0).setVisibility(View.VISIBLE);
}
public int getNoSearchResultsStringId() {
return R.string.no_search_results;
}
public LinearLayout getHeaderLayout() {
return mLayoutHeader;
}
public SegmentedButton getHeaderButton() {
return mHeaderButton;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
* Portions Copyright (c) 2008-2010 CommonsWare, LLC
*/
package com.joelapenna.foursquared.app;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
/**
* This is based off the chapter 13 sample in Advanced Android Development, by Mark Murphy.
*
* @date May 21, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class OnBootReceiver extends BroadcastReceiver {
public static final String TAG = "OnBootReceiver";
@Override
public void onReceive(Context context, Intent intent) {
// If the user has notifications on, set an alarm every N minutes, where N is their
// requested refresh rate.
PingsService.setupPings(context);
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
* Portions Copyright (c) 2008-2010 CommonsWare, LLC
*/
package com.joelapenna.foursquared.app;
import android.app.IntentService;
import android.content.Context;
import android.content.Intent;
import android.os.PowerManager;
/**
* This is based off the chapter 13 sample in Advanced Android Development, by Mark Murphy.
*
* @date May 21, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public abstract class WakefulIntentService extends IntentService {
public static final String TAG = "WakefulIntentService";
public static final String LOCK_NAME_STATIC = "com.joelapenna.foursquared.app.WakefulintentService.Static";
private static PowerManager.WakeLock lockStatic = null;
abstract void doWakefulWork(Intent intent);
public static void acquireStaticLock(Context context) {
getLock(context).acquire();
}
private synchronized static PowerManager.WakeLock getLock(Context context) {
if (lockStatic == null) {
PowerManager mgr = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
lockStatic = mgr.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, LOCK_NAME_STATIC);
lockStatic.setReferenceCounted(true);
}
return(lockStatic);
}
public WakefulIntentService(String name) {
super(name);
}
@Override
final protected void onHandleIntent(Intent intent) {
doWakefulWork(intent);
getLock(this).release();
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared.app;
import com.joelapenna.foursquared.R;
import android.app.ListActivity;
import android.os.Bundle;
import android.view.ViewGroup;
import android.view.Window;
import android.widget.ProgressBar;
import android.widget.TextView;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class LoadableListActivity extends ListActivity {
private int mNoSearchResultsString = getNoSearchResultsStringId();
private ProgressBar mEmptyProgress;
private TextView mEmptyText;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.loadable_list_activity);
mEmptyProgress = (ProgressBar)findViewById(R.id.emptyProgress);
mEmptyText = (TextView)findViewById(R.id.emptyText);
setLoadingView();
getListView().setDividerHeight(0);
}
public void setEmptyView() {
mEmptyProgress.setVisibility(ViewGroup.GONE);
mEmptyText.setText(mNoSearchResultsString);
}
public void setLoadingView() {
mEmptyProgress.setVisibility(ViewGroup.VISIBLE);
mEmptyText.setText("");//R.string.loading);
}
public void setLoadingView(String loadingText) {
setLoadingView();
mEmptyText.setText(loadingText);
}
public int getNoSearchResultsStringId() {
return R.string.no_search_results;
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.types.Checkin;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Mayor;
import com.joelapenna.foursquare.types.Stats;
import com.joelapenna.foursquare.types.Tip;
import com.joelapenna.foursquare.types.Todo;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.preferences.Preferences;
import com.joelapenna.foursquared.util.NotificationsUtil;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import com.joelapenna.foursquared.util.StringFormatters;
import com.joelapenna.foursquared.util.UserUtils;
import com.joelapenna.foursquared.util.VenueUtils;
import com.joelapenna.foursquared.widget.PhotoStrip;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.preference.PreferenceManager;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
/**
* We may be given a pre-fetched venue ready to display, or we might also get just
* a venue ID. If we only get a venue ID, then we need to fetch it immediately from
* the API.
*
* The activity will set an intent result in EXTRA_VENUE_RETURNED if the venue status
* changes as a result of a user modifying todos at the venue. Parent activities can
* check the returned venue to see if this status has changed to update their UI.
* For example, the NearbyVenues activity wants to show the todo corner png if the
* venue has a todo.
*
* The result will also be set if the venue is fully fetched if originally given only
* a venue id or partial venue object. This way the parent can also cache the full venue
* object for next time they want to display this venue activity.
*
* @author Joe LaPenna (joe@joelapenna.com)
* @author Mark Wyszomierski (markww@gmail.com)
* -Replaced shout activity with CheckinGatherInfoActivity (3/10/2010).
* -Redesign from tabbed layout (9/15/2010).
*/
public class VenueActivity extends Activity {
private static final String TAG = "VenueActivity";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private static final int MENU_TIP_ADD = 1;
private static final int MENU_TODO_ADD = 2;
private static final int MENU_EDIT_VENUE = 3;
private static final int MENU_CALL = 4;
private static final int MENU_SHARE = 5;
private static final int RESULT_CODE_ACTIVITY_CHECKIN_EXECUTE = 1;
private static final int RESULT_CODE_ACTIVITY_ADD_TIP = 2;
private static final int RESULT_CODE_ACTIVITY_ADD_TODO = 3;
private static final int RESULT_CODE_ACTIVITY_TIP = 4;
private static final int RESULT_CODE_ACTIVITY_TIPS = 5;
private static final int RESULT_CODE_ACTIVITY_TODO = 6;
private static final int RESULT_CODE_ACTIVITY_TODOS = 7;
public static final String INTENT_EXTRA_VENUE_ID = Foursquared.PACKAGE_NAME
+ ".VenueActivity.INTENT_EXTRA_VENUE_ID";
public static final String INTENT_EXTRA_VENUE_PARTIAL = Foursquared.PACKAGE_NAME
+ ".VenueActivity.INTENT_EXTRA_VENUE_PARTIAL";
public static final String INTENT_EXTRA_VENUE = Foursquared.PACKAGE_NAME
+ ".VenueActivity.INTENT_EXTRA_VENUE";
public static final String EXTRA_VENUE_RETURNED = Foursquared.PACKAGE_NAME
+ ".VenueActivity.EXTRA_VENUE_RETURNED";
private StateHolder mStateHolder;
private Handler mHandler;
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.venue_activity);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
mHandler = new Handler();
StateHolder holder = (StateHolder) getLastNonConfigurationInstance();
if (holder != null) {
mStateHolder = holder;
mStateHolder.setActivityForTasks(this);
prepareResultIntent();
} else {
mStateHolder = new StateHolder();
if (getIntent().hasExtra(INTENT_EXTRA_VENUE)) {
mStateHolder.setLoadType(StateHolder.LOAD_TYPE_VENUE_FULL);
mStateHolder.setVenue((Venue)getIntent().getParcelableExtra(INTENT_EXTRA_VENUE));
} else if (getIntent().hasExtra(INTENT_EXTRA_VENUE_PARTIAL)) {
mStateHolder.setLoadType(StateHolder.LOAD_TYPE_VENUE_PARTIAL);
mStateHolder.setVenue((Venue)getIntent().getParcelableExtra(INTENT_EXTRA_VENUE_PARTIAL));
mStateHolder.startTaskVenue(this);
} else if (getIntent().hasExtra(INTENT_EXTRA_VENUE_ID)) {
mStateHolder.setLoadType(StateHolder.LOAD_TYPE_VENUE_ID);
mStateHolder.setVenueId(getIntent().getStringExtra(INTENT_EXTRA_VENUE_ID));
mStateHolder.startTaskVenue(this);
} else {
Log.e(TAG, "VenueActivity must be given a venue id or a venue parcel as intent extras.");
finish();
return;
}
}
mRrm = ((Foursquared) getApplication()).getRemoteResourceManager();
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
ensureUi();
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
mHandler.removeCallbacks(mRunnableMayorPhoto);
if (mRrm != null) {
mRrm.deleteObserver(mResourcesObserver);
}
}
@Override
public void onResume() {
super.onResume();
ensureUiCheckinButton();
// TODO: ensure mayor photo.
}
private void ensureUi() {
TextView tvVenueTitle = (TextView)findViewById(R.id.venueActivityName);
TextView tvVenueAddress = (TextView)findViewById(R.id.venueActivityAddress);
LinearLayout progress = (LinearLayout)findViewById(R.id.venueActivityDetailsProgress);
View viewMayor = findViewById(R.id.venueActivityMayor);
TextView tvMayorTitle = (TextView)findViewById(R.id.venueActivityMayorName);
TextView tvMayorText = (TextView)findViewById(R.id.venueActivityMayorText);
ImageView ivMayorPhoto = (ImageView)findViewById(R.id.venueActivityMayorPhoto);
ImageView ivMayorChevron = (ImageView)findViewById(R.id.venueActivityMayorChevron);
View viewCheckins = findViewById(R.id.venueActivityCheckins);
TextView tvPeopleText = (TextView)findViewById(R.id.venueActivityPeopleText);
PhotoStrip psPeoplePhotos = (PhotoStrip)findViewById(R.id.venueActivityPeoplePhotos);
View viewTips = findViewById(R.id.venueActivityTips);
TextView tvTipsText = (TextView)findViewById(R.id.venueActivityTipsText);
TextView tvTipsTextExtra = (TextView)findViewById(R.id.venueActivityTipsExtra);
ImageView ivTipsChevron = (ImageView)findViewById(R.id.venueActivityTipsChevron);
View viewMoreInfo = findViewById(R.id.venueActivityMoreInfo);
TextView tvMoreInfoText = (TextView)findViewById(R.id.venueActivityMoreTitle);
Venue venue = mStateHolder.getVenue();
if (mStateHolder.getLoadType() == StateHolder.LOAD_TYPE_VENUE_FULL ||
mStateHolder.getLoadType() == StateHolder.LOAD_TYPE_VENUE_PARTIAL) {
tvVenueTitle.setText(venue.getName());
tvVenueAddress.setText(StringFormatters.getVenueLocationFull(venue));
ensureUiCheckinButton();
if (mStateHolder.getLoadType() == StateHolder.LOAD_TYPE_VENUE_FULL) {
Stats stats = venue.getStats();
Mayor mayor = stats != null ? stats.getMayor() : null;
if (mayor != null) {
tvMayorTitle.setText(StringFormatters.getUserFullName(mayor.getUser()));
tvMayorText.setText(getResources().getString(R.string.venue_activity_mayor_text));
String photoUrl = mayor.getUser().getPhoto();
Uri uriPhoto = Uri.parse(photoUrl);
if (mRrm.exists(uriPhoto)) {
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(Uri.parse(photoUrl)));
ivMayorPhoto.setImageBitmap(bitmap);
} catch (IOException e) {
}
} else {
ivMayorPhoto.setImageResource(UserUtils.getDrawableByGenderForUserThumbnail(mayor.getUser()));
ivMayorPhoto.setTag(photoUrl);
mRrm.request(uriPhoto);
}
ivMayorChevron.setVisibility(View.VISIBLE);
setClickHandlerMayor(viewMayor);
} else {
tvMayorTitle.setText(getResources().getString(R.string.venue_activity_mayor_name_none));
tvMayorText.setText(getResources().getString(R.string.venue_activity_mayor_text_none));
ivMayorChevron.setVisibility(View.INVISIBLE);
}
viewMayor.setVisibility(View.VISIBLE);
if (venue.getCheckins() != null && venue.getCheckins().size() > 0) {
int friendCount = getFriendCountAtVenue();
int rest = venue.getCheckins().size() - friendCount;
if (friendCount > 0 && rest == 0) {
// N friends are here
tvPeopleText.setText(getResources().getString(
friendCount == 1 ?
R.string.venue_activity_people_count_friend_single :
R.string.venue_activity_people_count_friend_plural,
friendCount));
} else if (friendCount > 0 && rest > 0) {
// N friends are here with N other people
if (friendCount == 1 && rest == 1) {
tvPeopleText.setText(getString(R.string.venue_activity_people_count_friend_single_single,
friendCount, rest));
} else if (friendCount == 1 && rest > 1) {
tvPeopleText.setText(getString(R.string.venue_activity_people_count_friend_single_plural,
friendCount, rest));
} else if (friendCount > 1 && rest == 1) {
tvPeopleText.setText(getString(R.string.venue_activity_people_count_friend_plural_single,
friendCount, rest));
} else {
tvPeopleText.setText(getString(R.string.venue_activity_people_count_friend_plural_plural,
friendCount, rest));
}
} else {
// N people are here
tvPeopleText.setText(getResources().getString(
venue.getCheckins().size() == 1 ?
R.string.venue_activity_people_count_single :
R.string.venue_activity_people_count_plural,
venue.getCheckins().size()));
}
psPeoplePhotos.setCheckinsAndRemoteResourcesManager(venue.getCheckins(), mRrm);
viewCheckins.setVisibility(View.VISIBLE);
setClickHandlerCheckins(viewCheckins);
} else {
viewCheckins.setVisibility(View.GONE);
}
if (venue.getTips() != null && venue.getTips().size() > 0) {
int tipCountFriends = getTipCountFriendsAtVenue();
if (tipCountFriends > 0) {
tvTipsText.setText(
getString(tipCountFriends == 1 ?
R.string.venue_activity_tip_count_friend_single :
R.string.venue_activity_tip_count_friend_plural,
tipCountFriends));
int rest = venue.getTips().size() - tipCountFriends;
if (rest > 0) {
tvTipsTextExtra.setText(
getString(R.string.venue_activity_tip_count_other_people, rest));
tvTipsTextExtra.setVisibility(View.VISIBLE);
}
} else {
tvTipsText.setText(
getString(venue.getTips().size() == 1 ?
R.string.venue_activity_tip_count_single :
R.string.venue_activity_tip_count_plural,
venue.getTips().size()));
tvTipsTextExtra.setVisibility(View.GONE);
}
ivTipsChevron.setVisibility(View.VISIBLE);
setClickHandlerTips(viewTips);
} else {
tvTipsText.setText(getResources().getString(R.string.venue_activity_tip_count_none));
tvTipsTextExtra.setVisibility(View.GONE);
ivTipsChevron.setVisibility(View.INVISIBLE);
}
viewTips.setVisibility(View.VISIBLE);
if (tvTipsTextExtra.getVisibility() != View.VISIBLE) {
tvTipsText.setPadding(tvTipsText.getPaddingLeft(), tvMoreInfoText.getPaddingTop(),
tvTipsText.getPaddingRight(), tvMoreInfoText.getPaddingBottom());
}
viewMoreInfo.setVisibility(View.VISIBLE);
setClickHandlerMoreInfo(viewMoreInfo);
progress.setVisibility(View.GONE);
}
}
ensureUiTodosHere();
ImageView ivSpecialHere = (ImageView)findViewById(R.id.venueActivitySpecialHere);
if (VenueUtils.getSpecialHere(venue)) {
ivSpecialHere.setVisibility(View.VISIBLE);
ivSpecialHere.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
showWebViewForSpecial();
}
});
} else {
ivSpecialHere.setVisibility(View.GONE);
}
}
private void ensureUiCheckinButton() {
Button btnCheckin = (Button)findViewById(R.id.venueActivityButtonCheckin);
if (mStateHolder.getCheckedInHere()) {
btnCheckin.setEnabled(false);
} else {
if (mStateHolder.getLoadType() == StateHolder.LOAD_TYPE_VENUE_ID) {
btnCheckin.setEnabled(false);
} else {
btnCheckin.setEnabled(true);
btnCheckin.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(
VenueActivity.this);
if (settings.getBoolean(Preferences.PREFERENCE_IMMEDIATE_CHECKIN, false)) {
startCheckinQuick();
} else {
startCheckin();
}
}
});
}
}
}
private void ensureUiTipAdded() {
Venue venue = mStateHolder.getVenue();
TextView tvTipsText = (TextView)findViewById(R.id.venueActivityTipsText);
ImageView ivTipsChevron = (ImageView)findViewById(R.id.venueActivityTipsChevron);
if (venue.getTips().size() == 1) {
tvTipsText.setText(getResources().getString(
R.string.venue_activity_tip_count_single, venue.getTips().size()));
} else {
tvTipsText.setText(getResources().getString(
R.string.venue_activity_tip_count_plural, venue.getTips().size()));
}
ivTipsChevron.setVisibility(View.VISIBLE);
}
private void ensureUiTodosHere() {
Venue venue = mStateHolder.getVenue();
RelativeLayout rlTodoHere = (RelativeLayout)findViewById(R.id.venueActivityTodoHere);
if (venue != null && venue.getHasTodo()) {
rlTodoHere.setVisibility(View.VISIBLE);
rlTodoHere.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
showTodoHereActivity();
}
});
} else {
rlTodoHere.setVisibility(View.GONE);
}
}
private void setClickHandlerMayor(View view) {
view.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(VenueActivity.this, UserDetailsActivity.class);
intent.putExtra(UserDetailsActivity.EXTRA_USER_PARCEL,
mStateHolder.getVenue().getStats().getMayor().getUser());
intent.putExtra(UserDetailsActivity.EXTRA_SHOW_ADD_FRIEND_OPTIONS, true);
startActivity(intent);
}
});
}
private void setClickHandlerCheckins(View view) {
view.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(VenueActivity.this, VenueCheckinsActivity.class);
intent.putExtra(VenueCheckinsActivity.INTENT_EXTRA_VENUE, mStateHolder.getVenue());
startActivity(intent);
}
});
}
private void setClickHandlerTips(View view) {
view.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = null;
if (mStateHolder.getVenue().getTips().size() == 1) {
Venue venue = new Venue();
venue.setName(mStateHolder.getVenue().getName());
venue.setAddress(mStateHolder.getVenue().getAddress());
venue.setCrossstreet(mStateHolder.getVenue().getCrossstreet());
Tip tip = mStateHolder.getVenue().getTips().get(0);
tip.setVenue(venue);
intent = new Intent(VenueActivity.this, TipActivity.class);
intent.putExtra(TipActivity.EXTRA_TIP_PARCEL, tip);
intent.putExtra(TipActivity.EXTRA_VENUE_CLICKABLE, false);
startActivityForResult(intent, RESULT_CODE_ACTIVITY_TIP);
} else {
intent = new Intent(VenueActivity.this, VenueTipsActivity.class);
intent.putExtra(VenueTipsActivity.INTENT_EXTRA_VENUE, mStateHolder.getVenue());
startActivityForResult(intent, RESULT_CODE_ACTIVITY_TIPS);
}
}
});
}
private void setClickHandlerMoreInfo(View view) {
view.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(VenueActivity.this, VenueMapActivity.class);
intent.putExtra(VenueMapActivity.INTENT_EXTRA_VENUE, mStateHolder.getVenue());
startActivity(intent);
}
});
}
private void prepareResultIntent() {
Venue venue = mStateHolder.getVenue();
Intent intent = new Intent();
if (venue != null) {
intent.putExtra(EXTRA_VENUE_RETURNED, venue);
}
setResult(Activity.RESULT_OK, intent);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
menu.add(Menu.NONE, MENU_TIP_ADD, 1, R.string.venue_activity_menu_add_tip).setIcon(
R.drawable.ic_menu_venue_leave_tip);
menu.add(Menu.NONE, MENU_TODO_ADD, 2, R.string.venue_activity_menu_add_todo).setIcon(
R.drawable.ic_menu_venue_add_todo);
menu.add(Menu.NONE, MENU_EDIT_VENUE, 3, R.string.venue_activity_menu_flag).setIcon(
R.drawable.ic_menu_venue_flag);
menu.add(Menu.NONE, MENU_CALL, 4, R.string.venue_activity_menu_call).setIcon(
R.drawable.ic_menu_venue_contact);
menu.add(Menu.NONE, MENU_SHARE, 5, R.string.venue_activity_menu_share).setIcon(
R.drawable.ic_menu_venue_share);
return true;
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
boolean callEnabled = mStateHolder.getVenue() != null
&& !TextUtils.isEmpty(mStateHolder.getVenue().getPhone());
menu.findItem(MENU_CALL).setEnabled(callEnabled);
return super.onPrepareOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_TIP_ADD:
Intent intentTip = new Intent(VenueActivity.this, AddTipActivity.class);
intentTip.putExtra(AddTipActivity.INTENT_EXTRA_VENUE, mStateHolder.getVenue());
startActivityForResult(intentTip, RESULT_CODE_ACTIVITY_ADD_TIP);
return true;
case MENU_TODO_ADD:
Intent intentTodo = new Intent(VenueActivity.this, AddTodoActivity.class);
intentTodo.putExtra(AddTodoActivity.INTENT_EXTRA_VENUE, mStateHolder.getVenue());
startActivityForResult(intentTodo, RESULT_CODE_ACTIVITY_ADD_TODO);
return true;
case MENU_EDIT_VENUE:
Intent intentEditVenue = new Intent(this, EditVenueOptionsActivity.class);
intentEditVenue.putExtra(
EditVenueOptionsActivity.EXTRA_VENUE_PARCELABLE, mStateHolder.getVenue());
startActivity(intentEditVenue);
return true;
case MENU_CALL:
try {
Intent dial = new Intent();
dial.setAction(Intent.ACTION_DIAL);
dial.setData(Uri.parse("tel:" + mStateHolder.getVenue().getPhone()));
startActivity(dial);
} catch (Exception ex) {
Log.e(TAG, "Error starting phone dialer intent.", ex);
Toast.makeText(this, "Sorry, we couldn't find any app to place a phone call!",
Toast.LENGTH_SHORT).show();
}
return true;
case MENU_SHARE:
Intent intentShare = new Intent(this, VenueShareActivity.class);
intentShare.putExtra(VenueShareActivity.INTENT_EXTRA_VENUE, mStateHolder.getVenue());
startActivity(intentShare);
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivityForTasks(null);
return mStateHolder;
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
case RESULT_CODE_ACTIVITY_CHECKIN_EXECUTE:
if (resultCode == Activity.RESULT_OK) {
mStateHolder.setCheckedInHere(true);
ensureUiCheckinButton();
}
break;
case RESULT_CODE_ACTIVITY_ADD_TIP:
if (resultCode == Activity.RESULT_OK) {
Tip tip = data.getParcelableExtra(AddTipActivity.EXTRA_TIP_RETURNED);
VenueUtils.addTip(mStateHolder.getVenue(), tip);
ensureUiTipAdded();
prepareResultIntent();
Toast.makeText(this, getResources().getString(R.string.venue_activity_tip_added_ok),
Toast.LENGTH_SHORT).show();
}
break;
case RESULT_CODE_ACTIVITY_ADD_TODO:
if (resultCode == Activity.RESULT_OK) {
Todo todo = data.getParcelableExtra(AddTodoActivity.EXTRA_TODO_RETURNED);
VenueUtils.addTodo(mStateHolder.getVenue(), todo.getTip(), todo);
ensureUiTodosHere();
prepareResultIntent();
Toast.makeText(this, getResources().getString(R.string.venue_activity_todo_added_ok),
Toast.LENGTH_SHORT).show();
}
break;
case RESULT_CODE_ACTIVITY_TIP:
case RESULT_CODE_ACTIVITY_TODO:
if (resultCode == Activity.RESULT_OK && data.hasExtra(TipActivity.EXTRA_TIP_RETURNED)) {
Tip tip = (Tip)data.getParcelableExtra(TipActivity.EXTRA_TIP_RETURNED);
Todo todo = data.hasExtra(TipActivity.EXTRA_TODO_RETURNED) ?
(Todo)data.getParcelableExtra(TipActivity.EXTRA_TODO_RETURNED) : null;
VenueUtils.handleTipChange(mStateHolder.getVenue(), tip, todo);
ensureUiTodosHere();
prepareResultIntent();
}
break;
case RESULT_CODE_ACTIVITY_TIPS:
if (resultCode == Activity.RESULT_OK && data.hasExtra(VenueTipsActivity.INTENT_EXTRA_RETURN_VENUE)) {
Venue venue = (Venue)data.getParcelableExtra(VenueTipsActivity.INTENT_EXTRA_RETURN_VENUE);
VenueUtils.replaceTipsAndTodos(mStateHolder.getVenue(), venue);
ensureUiTodosHere();
prepareResultIntent();
}
break;
case RESULT_CODE_ACTIVITY_TODOS:
if (resultCode == Activity.RESULT_OK && data.hasExtra(VenueTodosActivity.INTENT_EXTRA_RETURN_VENUE)) {
Venue venue = (Venue)data.getParcelableExtra(VenueTodosActivity.INTENT_EXTRA_RETURN_VENUE);
VenueUtils.replaceTipsAndTodos(mStateHolder.getVenue(), venue);
ensureUiTodosHere();
prepareResultIntent();
}
break;
}
}
private void startCheckin() {
Intent intent = new Intent(this, CheckinOrShoutGatherInfoActivity.class);
intent.putExtra(CheckinOrShoutGatherInfoActivity.INTENT_EXTRA_IS_CHECKIN, true);
intent.putExtra(CheckinOrShoutGatherInfoActivity.INTENT_EXTRA_VENUE_ID, mStateHolder.getVenue().getId());
intent.putExtra(CheckinOrShoutGatherInfoActivity.INTENT_EXTRA_VENUE_NAME, mStateHolder.getVenue().getName());
startActivityForResult(intent, RESULT_CODE_ACTIVITY_CHECKIN_EXECUTE);
}
private void startCheckinQuick() {
SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(this);
boolean tellFriends = settings.getBoolean(Preferences.PREFERENCE_SHARE_CHECKIN, true);
boolean tellTwitter = settings.getBoolean(Preferences.PREFERENCE_TWITTER_CHECKIN, false);
boolean tellFacebook = settings.getBoolean(Preferences.PREFERENCE_FACEBOOK_CHECKIN, false);
Intent intent = new Intent(VenueActivity.this, CheckinExecuteActivity.class);
intent.putExtra(CheckinExecuteActivity.INTENT_EXTRA_VENUE_ID, mStateHolder.getVenue().getId());
intent.putExtra(CheckinExecuteActivity.INTENT_EXTRA_SHOUT, "");
intent.putExtra(CheckinExecuteActivity.INTENT_EXTRA_TELL_FRIENDS, tellFriends);
intent.putExtra(CheckinExecuteActivity.INTENT_EXTRA_TELL_TWITTER, tellTwitter);
intent.putExtra(CheckinExecuteActivity.INTENT_EXTRA_TELL_FACEBOOK, tellFacebook);
startActivityForResult(intent, RESULT_CODE_ACTIVITY_CHECKIN_EXECUTE);
}
private void showWebViewForSpecial() {
Intent intent = new Intent(this, SpecialWebViewActivity.class);
intent.putExtra(SpecialWebViewActivity.EXTRA_CREDENTIALS_USERNAME,
PreferenceManager.getDefaultSharedPreferences(this).getString(Preferences.PREFERENCE_LOGIN, ""));
intent.putExtra(SpecialWebViewActivity.EXTRA_CREDENTIALS_PASSWORD,
PreferenceManager.getDefaultSharedPreferences(this).getString(Preferences.PREFERENCE_PASSWORD, ""));
intent.putExtra(SpecialWebViewActivity.EXTRA_SPECIAL_ID,
mStateHolder.getVenue().getSpecials().get(0).getId());
startActivity(intent);
}
private void showTodoHereActivity() {
Venue venue = new Venue();
venue.setName(mStateHolder.getVenue().getName());
venue.setAddress(mStateHolder.getVenue().getAddress());
venue.setCrossstreet(mStateHolder.getVenue().getCrossstreet());
Group<Todo> todos = mStateHolder.getVenue().getTodos();
for (Todo it : todos) {
it.getTip().setVenue(venue);
}
if (todos.size() == 1) {
Todo todo = (Todo) todos.get(0);
Intent intent = new Intent(VenueActivity.this, TipActivity.class);
intent.putExtra(TipActivity.EXTRA_TIP_PARCEL, todo.getTip());
intent.putExtra(TipActivity.EXTRA_VENUE_CLICKABLE, false);
startActivityForResult(intent, RESULT_CODE_ACTIVITY_TODO);
} else if (todos.size() > 1) {
Intent intent = new Intent(VenueActivity.this, VenueTodosActivity.class);
intent.putExtra(VenueTodosActivity.INTENT_EXTRA_VENUE, mStateHolder.getVenue());
startActivityForResult(intent, RESULT_CODE_ACTIVITY_TODOS);
}
}
private int getFriendCountAtVenue() {
int count = 0;
Venue venue = mStateHolder.getVenue();
if (venue.getCheckins() != null) {
for (Checkin it : venue.getCheckins()) {
User user = it.getUser();
if (UserUtils.isFriend(user)) {
count++;
}
}
}
return count;
}
private int getTipCountFriendsAtVenue() {
int count = 0;
Venue venue = mStateHolder.getVenue();
if (venue.getTips() != null) {
for (Tip it : venue.getTips()) {
User user = it.getUser();
if (UserUtils.isFriend(user)) {
count++;
}
}
}
return count;
}
private static class TaskVenue extends AsyncTask<String, Void, Venue> {
private VenueActivity mActivity;
private Exception mReason;
public TaskVenue(VenueActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
}
@Override
protected Venue doInBackground(String... params) {
try {
Foursquared foursquared = (Foursquared)mActivity.getApplication();
return foursquared.getFoursquare().venue(
params[0],
LocationUtils.createFoursquareLocation(foursquared.getLastKnownLocation()));
} catch (Exception e) {
Log.e(TAG, "Error getting venue details.", e);
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(Venue venue) {
if (mActivity != null) {
mActivity.mStateHolder.setIsRunningTaskVenue(false);
if (venue != null) {
mActivity.mStateHolder.setLoadType(StateHolder.LOAD_TYPE_VENUE_FULL);
mActivity.mStateHolder.setVenue(venue);
mActivity.prepareResultIntent();
mActivity.ensureUi();
} else {
NotificationsUtil.ToastReasonForFailure(mActivity, mReason);
mActivity.finish();
}
}
}
@Override
protected void onCancelled() {
}
public void setActivity(VenueActivity activity) {
mActivity = activity;
}
}
private static final class StateHolder {
private Venue mVenue;
private String mVenueId;
private boolean mCheckedInHere;
private TaskVenue mTaskVenue;
private boolean mIsRunningTaskVenue;
private int mLoadType;
public static final int LOAD_TYPE_VENUE_ID = 0;
public static final int LOAD_TYPE_VENUE_PARTIAL = 1;
public static final int LOAD_TYPE_VENUE_FULL = 2;
public StateHolder() {
mIsRunningTaskVenue = false;
}
public Venue getVenue() {
return mVenue;
}
public void setVenue(Venue venue) {
mVenue = venue;
}
public void setVenueId(String venueId) {
mVenueId = venueId;
}
public boolean getCheckedInHere() {
return mCheckedInHere;
}
public void setCheckedInHere(boolean checkedInHere) {
mCheckedInHere = checkedInHere;
}
public void setIsRunningTaskVenue(boolean isRunningTaskVenue) {
mIsRunningTaskVenue = isRunningTaskVenue;
}
public void startTaskVenue(VenueActivity activity) {
if (!mIsRunningTaskVenue) {
mIsRunningTaskVenue = true;
mTaskVenue = new TaskVenue(activity);
if (mLoadType == LOAD_TYPE_VENUE_ID) {
mTaskVenue.execute(mVenueId);
} else if (mLoadType == LOAD_TYPE_VENUE_PARTIAL) {
mTaskVenue.execute(mVenue.getId());
}
}
}
public void setActivityForTasks(VenueActivity activity) {
if (mTaskVenue != null) {
mTaskVenue.setActivity(activity);
}
}
public int getLoadType() {
return mLoadType;
}
public void setLoadType(int loadType) {
mLoadType = loadType;
}
}
/**
* Handles population of the mayor photo. The strip of checkin photos has its own
* internal observer.
*/
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
mHandler.post(mRunnableMayorPhoto);
}
}
private Runnable mRunnableMayorPhoto = new Runnable() {
@Override
public void run() {
ImageView ivMayorPhoto = (ImageView)findViewById(R.id.venueActivityMayorPhoto);
if (ivMayorPhoto.getTag() != null) {
String mayorPhotoUrl = (String)ivMayorPhoto.getTag();
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(Uri.parse(mayorPhotoUrl)));
ivMayorPhoto.setImageBitmap(bitmap);
ivMayorPhoto.setTag(null);
ivMayorPhoto.invalidate();
} catch (IOException ex) {
Log.e(TAG, "Error decoding mayor photo on notification, ignoring.", ex);
}
}
}
};
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapActivity;
import com.google.android.maps.MapController;
import com.google.android.maps.MapView;
import com.google.android.maps.MyLocationOverlay;
import com.google.android.maps.OverlayItem;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Stats;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquare.util.VenueUtils;
import com.joelapenna.foursquared.maps.CrashFixMyLocationOverlay;
import com.joelapenna.foursquared.maps.VenueItemizedOverlay;
import com.joelapenna.foursquared.widget.MapCalloutView;
import android.content.Intent;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import java.util.Observable;
import java.util.Observer;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class SearchVenuesMapActivity extends MapActivity {
public static final String TAG = "SearchVenuesMapActivity";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
private String mTappedVenueId;
private Observer mSearchResultsObserver;
private MapCalloutView mCallout;
private MapView mMapView;
private MapController mMapController;
private VenueItemizedOverlay mVenueItemizedOverlay;
private MyLocationOverlay mMyLocationOverlay;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.search_map_activity);
initMap();
mCallout = (MapCalloutView) findViewById(R.id.map_callout);
mCallout.setVisibility(View.GONE);
mCallout.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(SearchVenuesMapActivity.this, VenueActivity.class);
intent.setAction(Intent.ACTION_VIEW);
intent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_ID, mTappedVenueId);
startActivity(intent);
}
});
mSearchResultsObserver = new Observer() {
@Override
public void update(Observable observable, Object data) {
if (DEBUG) Log.d(TAG, "Observed search results change.");
clearMap();
loadSearchResults(SearchVenuesActivity.searchResultsObservable.getSearchResults());
recenterMap();
}
};
}
@Override
public void onResume() {
super.onResume();
if (DEBUG) Log.d(TAG, "onResume()");
mMyLocationOverlay.enableMyLocation();
// mMyLocationOverlay.enableCompass(); // Disabled due to a sdk 1.5 emulator bug
clearMap();
loadSearchResults(SearchVenuesActivity.searchResultsObservable.getSearchResults());
recenterMap();
SearchVenuesActivity.searchResultsObservable.addObserver(mSearchResultsObserver);
}
@Override
public void onPause() {
super.onPause();
if (DEBUG) Log.d(TAG, "onPause()");
mMyLocationOverlay.disableMyLocation();
mMyLocationOverlay.disableCompass();
SearchVenuesActivity.searchResultsObservable.deleteObserver(mSearchResultsObserver);
}
@Override
protected boolean isRouteDisplayed() {
return false;
}
private void initMap() {
mMapView = (MapView)findViewById(R.id.mapView);
mMapView.setBuiltInZoomControls(true);
mMapController = mMapView.getController();
mMyLocationOverlay = new CrashFixMyLocationOverlay(this, mMapView);
mMapView.getOverlays().add(mMyLocationOverlay);
mMyLocationOverlay.runOnFirstFix(new Runnable() {
public void run() {
if (DEBUG) Log.d(TAG, "runOnFirstFix()");
mMapView.getController().animateTo(mMyLocationOverlay.getMyLocation());
mMapView.getController().setZoom(16);
}
});
}
private void loadSearchResults(Group<Group<Venue>> searchResults) {
if (searchResults == null) {
if (DEBUG) Log.d(TAG, "no search results. Not loading.");
return;
}
if (DEBUG) Log.d(TAG, "Loading search results");
// Put our location on the map.
mMapView.getOverlays().add(mMyLocationOverlay);
Group<Venue> mappableVenues = new Group<Venue>();
mappableVenues.setType("Mappable Venues");
// For each group of venues.
final int groupCount = searchResults.size();
for (int groupIndex = 0; groupIndex < groupCount; groupIndex++) {
Group<Venue> group = searchResults.get(groupIndex);
// For each venue group
final int venueCount = group.size();
for (int venueIndex = 0; venueIndex < venueCount; venueIndex++) {
Venue venue = group.get(venueIndex);
if (VenueUtils.hasValidLocation(venue)) {
mappableVenues.add(venue);
}
}
}
// Construct the venues overlay and attach it if we have a mappable set of venues.
if (mappableVenues.size() > 0) {
mVenueItemizedOverlay = new VenueItemizedOverlayWithButton( //
this.getResources().getDrawable(R.drawable.map_marker_blue), //
this.getResources().getDrawable(R.drawable.map_marker_blue_muted));
mVenueItemizedOverlay.setGroup(mappableVenues);
mMapView.getOverlays().add(mVenueItemizedOverlay);
}
}
private void clearMap() {
if (DEBUG) Log.d(TAG, "clearMap()");
mMapView.getOverlays().clear();
mMapView.postInvalidate();
}
private void recenterMap() {
if (DEBUG) Log.d(TAG, "Recentering map.");
GeoPoint center = mMyLocationOverlay.getMyLocation();
// if we have venues in a search result, focus on those.
if (mVenueItemizedOverlay != null && mVenueItemizedOverlay.size() > 0) {
if (DEBUG) Log.d(TAG, "Centering on venues: "
+ String.valueOf(mVenueItemizedOverlay.getLatSpanE6()) + " "
+ String.valueOf(mVenueItemizedOverlay.getLonSpanE6()));
mMapController.setCenter(mVenueItemizedOverlay.getCenter());
mMapController.zoomToSpan(mVenueItemizedOverlay.getLatSpanE6(), mVenueItemizedOverlay
.getLonSpanE6());
} else if (center != null
&& SearchVenuesActivity.searchResultsObservable.getQuery() == SearchVenuesActivity.QUERY_NEARBY) {
if (DEBUG) Log.d(TAG, "recenterMap via MyLocation as we are doing a nearby search");
mMapController.animateTo(center);
mMapController.zoomToSpan(center.getLatitudeE6(), center.getLongitudeE6());
} else if (center != null) {
if (DEBUG) Log.d(TAG, "Fallback, recenterMap via MyLocation overlay");
mMapController.animateTo(center);
mMapController.setZoom(16);
return;
}
}
private class VenueItemizedOverlayWithButton extends VenueItemizedOverlay {
public static final String TAG = "VenueItemizedOverlayWithButton";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
private Drawable mBeenThereMarker;
public VenueItemizedOverlayWithButton(Drawable defaultMarker, Drawable beenThereMarker) {
super(defaultMarker);
mBeenThereMarker = boundCenterBottom(beenThereMarker);
}
@Override
public OverlayItem createItem(int i) {
VenueOverlayItem item = (VenueOverlayItem)super.createItem(i);
Stats stats = item.getVenue().getStats();
if (stats != null && stats.getBeenhere() != null && stats.getBeenhere().me()) {
if (DEBUG) Log.d(TAG, "using the beenThereMarker for: " + item.getVenue());
item.setMarker(mBeenThereMarker);
}
return item;
}
@Override
public boolean onTap(GeoPoint p, MapView mapView) {
if (DEBUG) Log.d(TAG, "onTap: " + this + " " + p + " " + mapView);
mCallout.setVisibility(View.GONE);
return super.onTap(p, mapView);
}
@Override
protected boolean onTap(int i) {
if (DEBUG) Log.d(TAG, "onTap: " + this + " " + i);
VenueOverlayItem item = (VenueOverlayItem)getItem(i);
mTappedVenueId = item.getVenue().getId();
mCallout.setTitle(item.getVenue().getName());
mCallout.setMessage(item.getVenue().getAddress());
mCallout.setVisibility(View.VISIBLE);
return true;
}
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import android.app.Activity;
import android.app.SearchManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.UriMatcher;
import android.net.Uri;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import java.net.URLDecoder;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class BrowsableActivity extends Activity {
private static final String TAG = "BrowsableActivity";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private static final int URI_PATH_CHECKIN = 1;
private static final int URI_PATH_CHECKINS = 2;
private static final int URI_PATH_SEARCH = 3;
private static final int URI_PATH_SHOUT = 4;
private static final int URI_PATH_USER = 5;
private static final int URI_PATH_VENUE = 6;
public static String PARAM_SHOUT_TEXT = "shout";
public static String PARAM_SEARCH_QUERY = "q";
public static String PARAM_SEARCH_IMMEDIATE= "immediate";
public static String PARAM_USER_ID= "uid";
private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
static {
sUriMatcher.addURI("m.foursquare.com", "checkin", URI_PATH_CHECKIN);
sUriMatcher.addURI("m.foursquare.com", "checkins", URI_PATH_CHECKINS);
sUriMatcher.addURI("m.foursquare.com", "search", URI_PATH_SEARCH);
sUriMatcher.addURI("m.foursquare.com", "shout", URI_PATH_SHOUT);
sUriMatcher.addURI("m.foursquare.com", "user", URI_PATH_USER);
sUriMatcher.addURI("m.foursquare.com", "venue/#", URI_PATH_VENUE);
}
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (DEBUG) Log.d(TAG, "onCreate()");
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
Uri uri = getIntent().getData();
if (DEBUG) Log.d(TAG, "Intent Data: " + uri);
Intent intent;
switch (sUriMatcher.match(uri)) {
case URI_PATH_CHECKIN:
if (DEBUG) Log.d(TAG, "Matched: URI_PATH_CHECKIN");
intent = new Intent(this, VenueActivity.class);
intent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_ID, uri.getQueryParameter("vid"));
startActivity(intent);
break;
case URI_PATH_CHECKINS:
if (DEBUG) Log.d(TAG, "Matched: URI_PATH_CHECKINS");
intent = new Intent(this, FriendsActivity.class);
startActivity(intent);
break;
case URI_PATH_SEARCH:
if (DEBUG) Log.d(TAG, "Matched: URI_PATH_SEARCH");
intent = new Intent(this, SearchVenuesActivity.class);
if (!TextUtils.isEmpty(uri.getQueryParameter(PARAM_SEARCH_QUERY))) {
intent.putExtra(SearchManager.QUERY, URLDecoder.decode(uri.getQueryParameter(PARAM_SEARCH_QUERY)));
if (uri.getQueryParameter(PARAM_SEARCH_IMMEDIATE) != null &&
uri.getQueryParameter(PARAM_SEARCH_IMMEDIATE).equals("1")) {
intent.setAction(Intent.ACTION_SEARCH); // interpret action as search immediately.
} else {
intent.setAction(Intent.ACTION_VIEW); // interpret as prepopulate search field only.
}
}
startActivity(intent);
break;
case URI_PATH_SHOUT:
if (DEBUG) Log.d(TAG, "Matched: URI_PATH_SHOUT");
intent = new Intent(this, CheckinOrShoutGatherInfoActivity.class);
intent.putExtra(CheckinOrShoutGatherInfoActivity.INTENT_EXTRA_IS_SHOUT, true);
if (!TextUtils.isEmpty(uri.getQueryParameter(PARAM_SHOUT_TEXT))) {
intent.putExtra(CheckinOrShoutGatherInfoActivity.INTENT_EXTRA_TEXT_PREPOPULATE,
URLDecoder.decode(uri.getQueryParameter(PARAM_SHOUT_TEXT)));
}
startActivity(intent);
break;
case URI_PATH_USER:
if (DEBUG) Log.d(TAG, "Matched: URI_PATH_USER");
intent = new Intent(this, UserDetailsActivity.class);
if (!TextUtils.isEmpty(uri.getQueryParameter(PARAM_USER_ID))) {
intent.putExtra(UserDetailsActivity.EXTRA_USER_ID,
uri.getQueryParameter(PARAM_USER_ID));
}
startActivity(intent);
break;
case URI_PATH_VENUE:
if (DEBUG) Log.d(TAG, "Matched: URI_PATH_VENUE");
intent = new Intent(this, VenueActivity.class);
intent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_ID, uri.getLastPathSegment());
startActivity(intent);
break;
default:
if (DEBUG) Log.d(TAG, "Matched: None");
}
finish();
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import android.app.Activity;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.util.Log;
import android.view.KeyEvent;
import android.view.Window;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.LinearLayout;
/**
* @date August 2, 2010.
* @author Mark Wyszomierski (markww@gmail.com).
*
*/
public class WebViewActivity extends Activity {
private static final String TAG = "WebViewActivity";
public static final String INTENT_EXTRA_URL = Foursquared.PACKAGE_NAME
+ ".WebViewActivity.INTENT_EXTRA_URL";
private WebView mWebView;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
mWebView = new WebView(this);
mWebView.setLayoutParams(new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.FILL_PARENT,
LinearLayout.LayoutParams.FILL_PARENT));
mWebView.getSettings().setJavaScriptEnabled(true);
mWebView.setWebViewClient(new EmbeddedWebViewClient());
if (getIntent().getStringExtra(INTENT_EXTRA_URL) != null) {
mWebView.loadUrl(getIntent().getStringExtra(INTENT_EXTRA_URL));
} else {
Log.e(TAG, "Missing url in intent extras.");
finish();
return;
}
setContentView(mWebView);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if ((keyCode == KeyEvent.KEYCODE_BACK) && mWebView.canGoBack()) {
mWebView.goBack();
return true;
}
return super.onKeyDown(keyCode, event);
}
private class EmbeddedWebViewClient extends WebViewClient {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return true;
}
@Override
public void onPageStarted(WebView view, String url, Bitmap favicon) {
super.onPageStarted(view, url, favicon);
setProgressBarIndeterminateVisibility(true);
}
@Override
public void onPageFinished(WebView view, String url) {
super.onPageFinished(view, url);
setProgressBarIndeterminateVisibility(false);
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.util.MenuUtils;
import com.joelapenna.foursquared.util.NotificationsUtil;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import com.joelapenna.foursquared.util.StringFormatters;
import com.joelapenna.foursquared.util.UiUtil;
import com.joelapenna.foursquared.util.UserUtils;
import com.joelapenna.foursquared.widget.PhotoStrip;
import com.joelapenna.foursquared.widget.UserContactAdapter;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Typeface;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.TextUtils;
import android.text.style.CharacterStyle;
import android.text.style.StyleSpan;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
/**
* @date March 8, 2010.
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class UserDetailsActivity extends Activity {
private static final String TAG = "UserDetailsActivity";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private static final int ACTIVITY_REQUEST_CODE_PINGS = 815;
private static final int ACTIVITY_REQUEST_CODE_FETCH_IMAGE = 816;
private static final int ACTIVITY_REQUEST_CODE_VIEW_AND_SET_IMAGE = 817;
public static final String EXTRA_USER_PARCEL = Foursquared.PACKAGE_NAME
+ ".UserDetailsActivity.EXTRA_USER_PARCEL";
public static final String EXTRA_USER_ID = Foursquared.PACKAGE_NAME
+ ".UserDetailsActivity.EXTRA_USER_ID";
public static final String EXTRA_SHOW_ADD_FRIEND_OPTIONS = Foursquared.PACKAGE_NAME
+ ".UserDetailsActivity.EXTRA_SHOW_ADD_FRIEND_OPTIONS";
private static final int LOAD_TYPE_USER_NONE = 0;
private static final int LOAD_TYPE_USER_ID = 1;
private static final int LOAD_TYPE_USER_PARTIAL = 2;
private static final int LOAD_TYPE_USER_FULL = 3;
private static final int MENU_REFRESH = 0;
private static final int MENU_CONTACT = 1;
private static final int MENU_PINGS = 2;
private static final int DIALOG_CONTACTS = 0;
private StateHolder mStateHolder;
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
private Handler mHandler;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.user_details_activity);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
Object retained = getLastNonConfigurationInstance();
if (retained != null) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivityForTasks(this);
} else {
mStateHolder = new StateHolder();
if (getIntent().hasExtra(EXTRA_USER_PARCEL)) {
Log.i(TAG, "Starting " + TAG + " with full user parcel.");
User user = getIntent().getExtras().getParcelable(EXTRA_USER_PARCEL);
mStateHolder.setUser(user);
mStateHolder.setLoadType(LOAD_TYPE_USER_PARTIAL);
} else if (getIntent().hasExtra(EXTRA_USER_ID)) {
Log.i(TAG, "Starting " + TAG + " with user ID.");
User user = new User();
user.setId(getIntent().getExtras().getString(EXTRA_USER_ID));
mStateHolder.setUser(user);
mStateHolder.setLoadType(LOAD_TYPE_USER_ID);
} else {
Log.i(TAG, "Starting " + TAG + " as logged-in user.");
User user = new User();
user.setId(null);
mStateHolder.setUser(user);
mStateHolder.setLoadType(LOAD_TYPE_USER_ID);
}
mStateHolder.setIsLoggedInUser(
mStateHolder.getUser().getId() == null ||
mStateHolder.getUser().getId().equals(
((Foursquared) getApplication()).getUserId()));
}
mHandler = new Handler();
mRrm = ((Foursquared) getApplication()).getRemoteResourceManager();
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
ensureUi();
if (mStateHolder.getLoadType() != LOAD_TYPE_USER_FULL &&
!mStateHolder.getIsRunningUserDetailsTask() &&
!mStateHolder.getRanOnce()) {
mStateHolder.startTaskUserDetails(this, mStateHolder.getUser().getId());
}
}
@Override
public void onPause() {
super.onPause();
if (isFinishing()) {
mStateHolder.cancelTasks();
mHandler.removeCallbacks(mRunnableUpdateUserPhoto);
RemoteResourceManager rrm = ((Foursquared) getApplication()).getRemoteResourceManager();
rrm.deleteObserver(mResourcesObserver);
}
}
@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
private void ensureUi() {
int sdk = UiUtil.sdkVersion();
View viewProgressBar = findViewById(R.id.venueActivityDetailsProgress);
TextView tvUsername = (TextView)findViewById(R.id.userDetailsActivityUsername);
TextView tvLastSeen = (TextView)findViewById(R.id.userDetailsActivityHometownOrLastSeen);
Button btnFriend = (Button)findViewById(R.id.userDetailsActivityFriendButton);
View viewMayorships = findViewById(R.id.userDetailsActivityGeneralMayorships);
View viewBadges = findViewById(R.id.userDetailsActivityGeneralBadges);
View viewTips = findViewById(R.id.userDetailsActivityGeneralTips);
TextView tvMayorships = (TextView)findViewById(R.id.userDetailsActivityGeneralMayorshipsValue);
TextView tvBadges = (TextView)findViewById(R.id.userDetailsActivityGeneralBadgesValue);
TextView tvTips = (TextView)findViewById(R.id.userDetailsActivityGeneralTipsValue);
ImageView ivMayorshipsChevron = (ImageView)findViewById(R.id.userDetailsActivityGeneralMayorshipsChevron);
ImageView ivBadgesChevron = (ImageView)findViewById(R.id.userDetailsActivityGeneralBadgesChevron);
ImageView ivTipsChevron = (ImageView)findViewById(R.id.userDetailsActivityGeneralTipsChevron);
View viewCheckins = findViewById(R.id.userDetailsActivityCheckins);
View viewFriendsFollowers = findViewById(R.id.userDetailsActivityFriendsFollowers);
View viewAddFriends = findViewById(R.id.userDetailsActivityAddFriends);
View viewTodos = findViewById(R.id.userDetailsActivityTodos);
View viewFriends = findViewById(R.id.userDetailsActivityFriends);
TextView tvCheckins = (TextView)findViewById(R.id.userDetailsActivityCheckinsText);
ImageView ivCheckinsChevron = (ImageView)findViewById(R.id.userDetailsActivityCheckinsChevron);
TextView tvFriendsFollowers = (TextView)findViewById(R.id.userDetailsActivityFriendsFollowersText);
ImageView ivFriendsFollowersChevron = (ImageView)findViewById(R.id.userDetailsActivityFriendsFollowersChevron);
TextView tvTodos = (TextView)findViewById(R.id.userDetailsActivityTodosText);
ImageView ivTodos = (ImageView)findViewById(R.id.userDetailsActivityTodosChevron);
TextView tvFriends = (TextView)findViewById(R.id.userDetailsActivityFriendsText);
ImageView ivFriends = (ImageView)findViewById(R.id.userDetailsActivityFriendsChevron);
PhotoStrip psFriends = (PhotoStrip)findViewById(R.id.userDetailsActivityFriendsPhotos);
viewProgressBar.setVisibility(View.VISIBLE);
tvUsername.setText("");
tvLastSeen.setText("");
viewMayorships.setFocusable(false);
viewBadges.setFocusable(false);
viewTips.setFocusable(false);
tvMayorships.setText("0");
tvBadges.setText("0");
tvTips.setText("0");
ivMayorshipsChevron.setVisibility(View.INVISIBLE);
ivBadgesChevron.setVisibility(View.INVISIBLE);
ivTipsChevron.setVisibility(View.INVISIBLE);
btnFriend.setVisibility(View.INVISIBLE);
viewCheckins.setFocusable(false);
viewFriendsFollowers.setFocusable(false);
viewAddFriends.setFocusable(false);
viewTodos.setFocusable(false);
viewFriends.setFocusable(false);
viewCheckins.setVisibility(View.GONE);
viewFriendsFollowers.setVisibility(View.GONE);
viewAddFriends.setVisibility(View.GONE);
viewTodos.setVisibility(View.GONE);
viewFriends.setVisibility(View.GONE);
ivCheckinsChevron.setVisibility(View.INVISIBLE);
ivFriendsFollowersChevron.setVisibility(View.INVISIBLE);
ivTodos.setVisibility(View.INVISIBLE);
ivFriends.setVisibility(View.INVISIBLE);
psFriends.setVisibility(View.GONE);
tvCheckins.setText("");
tvFriendsFollowers.setText("");
tvTodos.setText("");
tvFriends.setText("");
if (mStateHolder.getLoadType() >= LOAD_TYPE_USER_PARTIAL) {
User user = mStateHolder.getUser();
ensureUiPhoto(user);
if (mStateHolder.getIsLoggedInUser() || UserUtils.isFriend(user)) {
tvUsername.setText(StringFormatters.getUserFullName(user));
} else {
tvUsername.setText(StringFormatters.getUserAbbreviatedName(user));
}
tvLastSeen.setText(user.getHometown());
if (mStateHolder.getIsLoggedInUser() ||
UserUtils.isFriend(user) ||
UserUtils.isFriendStatusPendingThem(user) ||
UserUtils.isFriendStatusFollowingThem(user)) {
btnFriend.setVisibility(View.INVISIBLE);
} else if (UserUtils.isFriendStatusPendingYou(user)) {
btnFriend.setVisibility(View.VISIBLE);
btnFriend.setText(getString(R.string.user_details_activity_friend_confirm));
btnFriend.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
mStateHolder.startTaskFriend(UserDetailsActivity.this, StateHolder.TASK_FRIEND_ACCEPT);
}
});
} else {
btnFriend.setVisibility(View.VISIBLE);
btnFriend.setText(getString(R.string.user_details_activity_friend_add));
btnFriend.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
view.setEnabled(false);
mStateHolder.startTaskFriend(UserDetailsActivity.this, StateHolder.TASK_FRIEND_ADD);
}
});
}
if (mStateHolder.getLoadType() >= LOAD_TYPE_USER_FULL) {
viewProgressBar.setVisibility(View.GONE);
tvMayorships.setText(String.valueOf(user.getMayorCount()));
tvBadges.setText(String.valueOf(user.getBadgeCount()));
tvTips.setText(String.valueOf(user.getTipCount()));
if (user.getCheckin() != null && user.getCheckin().getVenue() != null) {
String fixed = getResources().getString(R.string.user_details_activity_last_seen);
String full = fixed + " " + user.getCheckin().getVenue().getName();
CharacterStyle bold = new StyleSpan(Typeface.BOLD);
SpannableString ss = new SpannableString(full);
ss.setSpan(bold, fixed.length(), full.length(), Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
tvLastSeen.setText(ss);
tvLastSeen.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
startVenueActivity();
}
});
}
if (user.getMayorships() != null && user.getMayorships().size() > 0) {
viewMayorships.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startMayorshipsActivity();
}
});
viewMayorships.setFocusable(true);
if (sdk > 3) {
ivMayorshipsChevron.setVisibility(View.VISIBLE);
}
}
if (user.getBadges() != null && user.getBadges().size() > 0) {
viewBadges.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startBadgesActivity();
}
});
viewBadges.setFocusable(true);
if (sdk > 3) {
ivBadgesChevron.setVisibility(View.VISIBLE);
}
}
if (user.getTipCount() > 0) {
viewTips.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startTipsActivity();
}
});
viewTips.setFocusable(true);
if (sdk > 3) {
ivTipsChevron.setVisibility(View.VISIBLE);
}
}
// The rest of the items depend on if we're viewing ourselves or not.
if (mStateHolder.getIsLoggedInUser()) {
viewCheckins.setVisibility(View.VISIBLE);
viewFriendsFollowers.setVisibility(View.VISIBLE);
viewAddFriends.setVisibility(View.VISIBLE);
tvCheckins.setText(
user.getCheckinCount() == 1 ?
getResources().getString(
R.string.user_details_activity_checkins_text_single, user.getCheckinCount()) :
getResources().getString(
R.string.user_details_activity_checkins_text_plural, user.getCheckinCount()));
if (user.getCheckinCount() > 0) {
viewCheckins.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startCheckinsActivity();
}
});
viewCheckins.setFocusable(true);
ivCheckinsChevron.setVisibility(View.VISIBLE);
}
if (user.getFollowerCount() > 0) {
tvFriendsFollowers.setText(
user.getFollowerCount() == 1 ?
getResources().getString(
R.string.user_details_activity_friends_followers_text_celeb_single,
user.getFollowerCount()) :
getResources().getString(
R.string.user_details_activity_friends_followers_text_celeb_plural,
user.getFollowerCount()));
if (user.getFriendCount() > 0) {
tvFriendsFollowers.setText(tvFriendsFollowers.getText() + ", ");
}
}
tvFriendsFollowers.setText(tvFriendsFollowers.getText().toString() +
(user.getFriendCount() == 1 ?
getResources().getString(
R.string.user_details_activity_friends_followers_text_single,
user.getFriendCount()) :
getResources().getString(
R.string.user_details_activity_friends_followers_text_plural,
user.getFriendCount())));
if (user.getFollowerCount() + user.getFriendCount() > 0) {
viewFriendsFollowers.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startFriendsFollowersActivity();
}
});
viewFriendsFollowers.setFocusable(true);
ivFriendsFollowersChevron.setVisibility(View.VISIBLE);
}
viewAddFriends.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startAddFriendsActivity();
}
});
viewAddFriends.setFocusable(true);
} else {
viewTodos.setVisibility(View.VISIBLE);
viewFriends.setVisibility(View.VISIBLE);
tvTodos.setText(
user.getTodoCount() == 1 ?
getResources().getString(
R.string.user_details_activity_todos_text_single, user.getTodoCount()) :
getResources().getString(
R.string.user_details_activity_todos_text_plural, user.getTodoCount()));
if (user.getTodoCount() > 0 && UserUtils.isFriend(user)) {
viewTodos.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startTodosActivity();
}
});
viewTodos.setFocusable(true);
ivTodos.setVisibility(View.VISIBLE);
}
tvFriends.setText(
user.getFriendCount() == 1 ?
getResources().getString(
R.string.user_details_activity_friends_text_single,
user.getFriendCount()) :
getResources().getString(
R.string.user_details_activity_friends_text_plural,
user.getFriendCount()));
int friendsInCommon = user.getFriendsInCommon() == null ? 0 :
user.getFriendsInCommon().size();
if (friendsInCommon > 0) {
tvFriends.setText(tvFriends.getText().toString() +
(friendsInCommon == 1 ?
getResources().getString(
R.string.user_details_activity_friends_in_common_text_single,
friendsInCommon) :
getResources().getString(
R.string.user_details_activity_friends_in_common_text_plural,
friendsInCommon)));
}
if (user.getFriendCount() > 0) {
viewFriends.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startFriendsInCommonActivity();
}
});
viewFriends.setFocusable(true);
ivFriends.setVisibility(View.VISIBLE);
}
if (friendsInCommon > 0) {
psFriends.setVisibility(View.VISIBLE);
psFriends.setUsersAndRemoteResourcesManager(user.getFriendsInCommon(), mRrm);
} else {
tvFriends.setPadding(tvFriends.getPaddingLeft(), tvTodos.getPaddingTop(),
tvFriends.getPaddingRight(), tvTodos.getPaddingBottom());
}
}
} else {
// Haven't done a full load.
if (mStateHolder.getRanOnce()) {
viewProgressBar.setVisibility(View.GONE);
}
}
} else {
// Haven't done a full load.
if (mStateHolder.getRanOnce()) {
viewProgressBar.setVisibility(View.GONE);
}
}
// Regardless of load state, if running a task, show titlebar progress bar.
if (mStateHolder.getIsTaskRunning()) {
setProgressBarIndeterminateVisibility(true);
} else {
setProgressBarIndeterminateVisibility(false);
}
// Disable friend button if running friend task.
if (mStateHolder.getIsRunningFriendTask()) {
btnFriend.setEnabled(false);
} else {
btnFriend.setEnabled(true);
}
}
private void ensureUiPhoto(User user) {
ImageView ivPhoto = (ImageView)findViewById(R.id.userDetailsActivityPhoto);
if (user == null || user.getPhoto() == null) {
ivPhoto.setImageResource(R.drawable.blank_boy);
return;
}
Uri uriPhoto = Uri.parse(user.getPhoto());
if (mRrm.exists(uriPhoto)) {
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(Uri.parse(user
.getPhoto())));
ivPhoto.setImageBitmap(bitmap);
} catch (IOException e) {
setUserPhotoMissing(ivPhoto, user);
}
} else {
mRrm.request(uriPhoto);
setUserPhotoMissing(ivPhoto, user);
}
ivPhoto.postInvalidate();
ivPhoto.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (mStateHolder.getLoadType() == LOAD_TYPE_USER_FULL) {
User user = mStateHolder.getUser();
// If "_thumbs" exists, remove it to get the url of the
// full-size image.
String photoUrl = user.getPhoto().replace("_thumbs", "");
// If we're viewing our own page, clicking the thumbnail should send the user
// to our built-in image viewer. Here we can give them the option of setting
// a new photo for themselves.
Intent intent = new Intent(UserDetailsActivity.this, FetchImageForViewIntent.class);
intent.putExtra(FetchImageForViewIntent.IMAGE_URL, photoUrl);
intent.putExtra(FetchImageForViewIntent.PROGRESS_BAR_MESSAGE, getResources()
.getString(R.string.user_activity_fetch_full_image_message));
if (mStateHolder.getIsLoggedInUser()) {
intent.putExtra(FetchImageForViewIntent.LAUNCH_VIEW_INTENT_ON_COMPLETION, false);
startActivityForResult(intent, ACTIVITY_REQUEST_CODE_FETCH_IMAGE);
} else {
startActivity(intent);
}
}
}
});
}
private void setUserPhotoMissing(ImageView ivPhoto, User user) {
if (Foursquare.MALE.equals(user.getGender())) {
ivPhoto.setImageResource(R.drawable.blank_boy);
} else {
ivPhoto.setImageResource(R.drawable.blank_girl);
}
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivityForTasks(null);
return mStateHolder;
}
private void startBadgesActivity() {
if (mStateHolder.getUser() != null) {
Intent intent = new Intent(UserDetailsActivity.this, BadgesActivity.class);
intent.putParcelableArrayListExtra(BadgesActivity.EXTRA_BADGE_ARRAY_LIST_PARCEL,
mStateHolder.getUser().getBadges());
intent.putExtra(BadgesActivity.EXTRA_USER_NAME, mStateHolder.getUser().getFirstname());
startActivity(intent);
}
}
private void startMayorshipsActivity() {
if (mStateHolder.getUser() != null) {
Intent intent = new Intent(UserDetailsActivity.this, UserMayorshipsActivity.class);
intent.putExtra(UserMayorshipsActivity.EXTRA_USER_ID, mStateHolder.getUser().getId());
intent.putExtra(UserMayorshipsActivity.EXTRA_USER_NAME, mStateHolder.getUser().getFirstname());
startActivity(intent);
}
}
private void startCheckinsActivity() {
Intent intent = new Intent(UserDetailsActivity.this, UserHistoryActivity.class);
intent.putExtra(UserHistoryActivity.EXTRA_USER_NAME, mStateHolder.getUser().getFirstname());
startActivity(intent);
}
private void startFriendsFollowersActivity() {
User user = mStateHolder.getUser();
Intent intent = null;
if (user.getFollowerCount() > 0) {
intent = new Intent(UserDetailsActivity.this, UserDetailsFriendsFollowersActivity.class);
intent.putExtra(UserDetailsFriendsFollowersActivity.EXTRA_USER_NAME, mStateHolder.getUser().getFirstname());
} else {
intent = new Intent(UserDetailsActivity.this, UserDetailsFriendsActivity.class);
intent.putExtra(UserDetailsFriendsActivity.EXTRA_USER_ID, mStateHolder.getUser().getId());
intent.putExtra(UserDetailsFriendsActivity.EXTRA_USER_NAME, mStateHolder.getUser().getFirstname());
}
startActivity(intent);
}
private void startAddFriendsActivity() {
Intent intent = new Intent(UserDetailsActivity.this, AddFriendsActivity.class);
startActivity(intent);
}
private void startFriendsInCommonActivity() {
User user = mStateHolder.getUser();
Intent intent = null;
if (user.getFriendsInCommon() != null && user.getFriendsInCommon().size() > 0) {
intent = new Intent(UserDetailsActivity.this, UserDetailsFriendsInCommonActivity.class);
intent.putExtra(UserDetailsFriendsInCommonActivity.EXTRA_USER_PARCEL, mStateHolder.getUser());
} else {
intent = new Intent(UserDetailsActivity.this, UserDetailsFriendsActivity.class);
intent.putExtra(UserDetailsFriendsActivity.EXTRA_USER_ID, mStateHolder.getUser().getId());
intent.putExtra(UserDetailsFriendsActivity.EXTRA_USER_NAME, mStateHolder.getUser().getFirstname());
}
startActivity(intent);
}
private void startTodosActivity() {
Intent intent = new Intent(UserDetailsActivity.this, TodosActivity.class);
intent.putExtra(TodosActivity.INTENT_EXTRA_USER_ID, mStateHolder.getUser().getId());
intent.putExtra(TodosActivity.INTENT_EXTRA_USER_NAME, mStateHolder.getUser().getFirstname());
startActivity(intent);
}
private void startTipsActivity() {
Intent intent = new Intent(UserDetailsActivity.this, UserDetailsTipsActivity.class);
intent.putExtra(UserDetailsTipsActivity.INTENT_EXTRA_USER_ID, mStateHolder.getUser().getId());
intent.putExtra(UserDetailsTipsActivity.INTENT_EXTRA_USER_NAME, mStateHolder.getUser().getFirstname());
startActivity(intent);
}
private void startVenueActivity() {
User user = mStateHolder.getUser();
if (user.getCheckin() != null &&
user.getCheckin().getVenue() != null) {
Intent intent = new Intent(this, VenueActivity.class);
intent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_PARTIAL, user.getCheckin().getVenue());
startActivity(intent);
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
menu.add(Menu.NONE, MENU_REFRESH, Menu.NONE, R.string.refresh)
.setIcon(R.drawable.ic_menu_refresh);
if (mStateHolder.getIsLoggedInUser()) {
MenuUtils.addPreferencesToMenu(this, menu);
} else {
menu.add(Menu.NONE, MENU_CONTACT, Menu.NONE, R.string.user_details_activity_friends_menu_contact)
.setIcon(R.drawable.ic_menu_user_contact);
if (UserUtils.isFriend(mStateHolder.getUser())) {
menu.add(Menu.NONE, MENU_PINGS, Menu.NONE, R.string.user_details_activity_friends_menu_pings)
.setIcon(android.R.drawable.ic_menu_rotate);
}
}
return true;
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
User user = mStateHolder.getUser();
MenuItem refresh = menu.findItem(MENU_REFRESH);
MenuItem contact = menu.findItem(MENU_CONTACT);
MenuItem pings = menu.findItem(MENU_PINGS);
if (!mStateHolder.getIsRunningUserDetailsTask()) {
refresh.setEnabled(true);
if (contact != null) {
boolean contactEnabled =
!TextUtils.isEmpty(user.getFacebook()) ||
!TextUtils.isEmpty(user.getTwitter()) ||
!TextUtils.isEmpty(user.getEmail()) ||
!TextUtils.isEmpty(user.getPhone());
contact.setEnabled(contactEnabled);
}
if (pings != null) {
pings.setEnabled(true);
}
} else {
refresh.setEnabled(false);
if (contact != null) {
contact.setEnabled(false);
}
if (pings != null) {
pings.setEnabled(false);
}
}
return super.onPrepareOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_REFRESH:
mStateHolder.startTaskUserDetails(this, mStateHolder.getUser().getId());
return true;
case MENU_CONTACT:
showDialog(DIALOG_CONTACTS);
return true;
case MENU_PINGS:
Intent intentPings = new Intent(this, UserDetailsPingsActivity.class);
intentPings.putExtra(UserDetailsPingsActivity.EXTRA_USER_PARCEL, mStateHolder.getUser());
startActivityForResult(intentPings, ACTIVITY_REQUEST_CODE_PINGS);
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
case ACTIVITY_REQUEST_CODE_PINGS:
if (resultCode == Activity.RESULT_OK) {
User user = (User)data.getParcelableExtra(UserDetailsPingsActivity.EXTRA_USER_RETURNED);
if (user != null) {
mStateHolder.getUser().getSettings().setGetPings(user.getSettings().getGetPings());
}
}
break;
case ACTIVITY_REQUEST_CODE_FETCH_IMAGE:
if (resultCode == Activity.RESULT_OK) {
String imagePath = data.getStringExtra(FetchImageForViewIntent.EXTRA_SAVED_IMAGE_PATH_RETURNED);
if (mStateHolder.getIsLoggedInUser() && !TextUtils.isEmpty(imagePath)) {
Intent intent = new Intent(this, FullSizeImageActivity.class);
intent.putExtra(FullSizeImageActivity.INTENT_EXTRA_IMAGE_PATH, imagePath);
intent.putExtra(FullSizeImageActivity.INTENT_EXTRA_ALLOW_SET_NEW_PHOTO, true);
startActivityForResult(intent, ACTIVITY_REQUEST_CODE_VIEW_AND_SET_IMAGE);
}
}
break;
case ACTIVITY_REQUEST_CODE_VIEW_AND_SET_IMAGE:
if (resultCode == Activity.RESULT_OK) {
String imageUrl = data.getStringExtra(FullSizeImageActivity.INTENT_RETURN_NEW_PHOTO_URL);
if (!TextUtils.isEmpty(imageUrl)) {
mStateHolder.getUser().setPhoto(imageUrl);
ensureUiPhoto(mStateHolder.getUser());
}
}
break;
}
}
@Override
protected Dialog onCreateDialog(int id) {
switch (id) {
case DIALOG_CONTACTS:
final UserContactAdapter adapter = new UserContactAdapter(this, mStateHolder.getUser());
AlertDialog dlgInfo = new AlertDialog.Builder(this)
.setTitle(getResources().getString(R.string.user_details_activity_friends_menu_contact))
.setAdapter(adapter, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dlg, int pos) {
UserContactAdapter.Action action = (UserContactAdapter.Action)adapter.getItem(pos);
switch (action.getActionId()) {
case UserContactAdapter.Action.ACTION_ID_SMS:
UiUtil.startSmsIntent(UserDetailsActivity.this, mStateHolder.getUser().getPhone());
break;
case UserContactAdapter.Action.ACTION_ID_EMAIL:
UiUtil.startEmailIntent(UserDetailsActivity.this, mStateHolder.getUser().getEmail());
break;
case UserContactAdapter.Action.ACTION_ID_PHONE:
UiUtil.startDialer(UserDetailsActivity.this, mStateHolder.getUser().getPhone());
break;
case UserContactAdapter.Action.ACTION_ID_TWITTER:
UiUtil.startWebIntent(UserDetailsActivity.this, "http://www.twitter.com/" +
mStateHolder.getUser().getTwitter());
break;
case UserContactAdapter.Action.ACTION_ID_FACEBOOK:
UiUtil.startWebIntent(UserDetailsActivity.this, "http://www.facebook.com/profile.php?id=" +
mStateHolder.getUser().getFacebook());
break;
}
}
})
.create();
return dlgInfo;
}
return null;
}
private void onUserDetailsTaskComplete(User user, Exception ex) {
mStateHolder.setIsRunningUserDetailsTask(false);
mStateHolder.setRanOnce(true);
if (user != null) {
mStateHolder.setUser(user);
mStateHolder.setLoadType(LOAD_TYPE_USER_FULL);
} else if (ex != null) {
NotificationsUtil.ToastReasonForFailure(this, ex);
} else {
Toast.makeText(this, "A surprising new error has occurred!", Toast.LENGTH_SHORT).show();
}
ensureUi();
}
/**
* Even if the caller supplies us with a User object parcelable, it won't
* have all the badge etc extra info in it. As soon as the activity starts,
* we launch this task to fetch a full user object, and merge it with
* whatever is already supplied in mUser.
*/
private static class UserDetailsTask extends AsyncTask<String, Void, User> {
private UserDetailsActivity mActivity;
private Exception mReason;
public UserDetailsTask(UserDetailsActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
mActivity.ensureUi();
}
@Override
protected User doInBackground(String... params) {
try {
return ((Foursquared) mActivity.getApplication()).getFoursquare().user(
params[0],
true,
true,
true,
LocationUtils.createFoursquareLocation(((Foursquared) mActivity
.getApplication()).getLastKnownLocation()));
} catch (Exception e) {
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(User user) {
if (mActivity != null) {
mActivity.onUserDetailsTaskComplete(user, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onUserDetailsTaskComplete(null, mReason);
}
}
public void setActivity(UserDetailsActivity activity) {
mActivity = activity;
}
}
private void onFriendTaskComplete(User user, int action, Exception ex) {
mStateHolder.setIsRunningFriendTask(false);
// The api isn't returning an updated friend status flag here, so we'll
// overwrite it manually for now, assuming success if the user object
// was not null.
User userCurrent = mStateHolder.getUser();
if (user != null) {
switch (action) {
case StateHolder.TASK_FRIEND_ACCEPT:
userCurrent.setFirstname(user.getFirstname());
userCurrent.setLastname(user.getLastname());
userCurrent.setFriendstatus("friend");
break;
case StateHolder.TASK_FRIEND_ADD:
userCurrent.setFriendstatus("pendingthem");
break;
}
} else {
NotificationsUtil.ToastReasonForFailure(this, ex);
}
ensureUi();
}
private static class FriendTask extends AsyncTask<Void, Void, User> {
private UserDetailsActivity mActivity;
private String mUserId;
private int mAction;
private Exception mReason;
public FriendTask(UserDetailsActivity activity, String userId, int action) {
mActivity = activity;
mUserId = userId;
mAction = action;
}
@Override
protected void onPreExecute() {
mActivity.ensureUi();
}
@Override
protected User doInBackground(Void... params) {
Foursquare foursquare = ((Foursquared) mActivity.getApplication()).getFoursquare();
try {
switch (mAction) {
case StateHolder.TASK_FRIEND_ACCEPT:
return foursquare.friendApprove(mUserId);
case StateHolder.TASK_FRIEND_ADD:
return foursquare.friendSendrequest(mUserId);
default:
throw new FoursquareException("Unknown action type supplied.");
}
} catch (Exception e) {
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(User user) {
if (mActivity != null) {
mActivity.onFriendTaskComplete(user, mAction, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onFriendTaskComplete(null, mAction, mReason);
}
}
public void setActivity(UserDetailsActivity activity) {
mActivity = activity;
}
}
private static class StateHolder {
public static final int TASK_FRIEND_ACCEPT = 0;
public static final int TASK_FRIEND_ADD = 1;
private User mUser;
private boolean mIsLoggedInUser;
private UserDetailsTask mTaskUserDetails;
private boolean mIsRunningUserDetailsTask;
private boolean mRanOnce;
private int mLoadType;
private FriendTask mTaskFriend;
private boolean mIsRunningFriendTask;
public StateHolder() {
mIsRunningUserDetailsTask = false;
mIsRunningFriendTask = false;
mIsLoggedInUser = false;
mRanOnce = false;
mLoadType = LOAD_TYPE_USER_NONE;
}
public boolean getIsLoggedInUser() {
return mIsLoggedInUser;
}
public void setIsLoggedInUser(boolean isLoggedInUser) {
mIsLoggedInUser = isLoggedInUser;
}
public User getUser() {
return mUser;
}
public void setUser(User user) {
mUser = user;
}
public int getLoadType() {
return mLoadType;
}
public void setLoadType(int loadType) {
mLoadType = loadType;
}
public void startTaskUserDetails(UserDetailsActivity activity, String userId) {
if (!mIsRunningUserDetailsTask) {
mIsRunningUserDetailsTask = true;
mTaskUserDetails = new UserDetailsTask(activity);
mTaskUserDetails.execute(userId);
}
}
public void startTaskFriend(UserDetailsActivity activity, int action) {
if (!mIsRunningFriendTask) {
mIsRunningFriendTask = true;
mTaskFriend = new FriendTask(activity, mUser.getId(), action);
mTaskFriend.execute();
}
}
public void setActivityForTasks(UserDetailsActivity activity) {
if (mTaskUserDetails != null) {
mTaskUserDetails.setActivity(activity);
}
if (mTaskFriend != null) {
mTaskFriend.setActivity(activity);
}
}
public boolean getIsRunningUserDetailsTask() {
return mIsRunningUserDetailsTask;
}
public void setIsRunningUserDetailsTask(boolean isRunning) {
mIsRunningUserDetailsTask = isRunning;
}
public boolean getRanOnce() {
return mRanOnce;
}
public void setRanOnce(boolean ranOnce) {
mRanOnce = ranOnce;
}
public boolean getIsRunningFriendTask() {
return mIsRunningFriendTask;
}
public void setIsRunningFriendTask(boolean isRunning) {
mIsRunningFriendTask = isRunning;
}
public void cancelTasks() {
if (mTaskUserDetails != null) {
mTaskUserDetails.setActivity(null);
mTaskUserDetails.cancel(true);
}
if (mTaskFriend != null) {
mTaskFriend.setActivity(null);
mTaskFriend.cancel(true);
}
}
public boolean getIsTaskRunning() {
return mIsRunningUserDetailsTask || mIsRunningFriendTask;
}
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
mHandler.post(mRunnableUpdateUserPhoto);
}
}
private Runnable mRunnableUpdateUserPhoto = new Runnable() {
@Override
public void run() {
ensureUiPhoto(mStateHolder.getUser());
}
};
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import com.joelapenna.foursquare.types.Tip;
import com.joelapenna.foursquare.types.Todo;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.util.NotificationsUtil;
import com.joelapenna.foursquared.util.StringFormatters;
/**
* Lets the user add a todo for a venue.
*
* @date September 16, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class AddTodoActivity extends Activity {
private static final String TAG = "AddTodoActivity";
public static final String INTENT_EXTRA_VENUE = Foursquared.PACKAGE_NAME
+ ".AddTodoActivity.INTENT_EXTRA_VENUE";
public static final String EXTRA_TODO_RETURNED = Foursquared.PACKAGE_NAME
+ ".AddTodoActivity.EXTRA_TODO_RETURNED";
private StateHolder mStateHolder;
private ProgressDialog mDlgProgress;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.add_todo_activity);
StateHolder holder = (StateHolder) getLastNonConfigurationInstance();
if (holder != null) {
mStateHolder = holder;
mStateHolder.setActivityForTasks(this);
} else {
mStateHolder = new StateHolder();
if (getIntent().hasExtra(INTENT_EXTRA_VENUE)) {
mStateHolder.setVenue((Venue)getIntent().getParcelableExtra(INTENT_EXTRA_VENUE));
} else {
Log.e(TAG, "AddTodoActivity must be given a venue parcel as intent extras.");
finish();
return;
}
}
ensureUi();
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivityForTasks(null);
return mStateHolder;
}
private void ensureUi() {
TextView tvVenueName = (TextView)findViewById(R.id.addTodoActivityVenueName);
tvVenueName.setText(mStateHolder.getVenue().getName());
TextView tvVenueAddress = (TextView)findViewById(R.id.addTodoActivityVenueAddress);
tvVenueAddress.setText(StringFormatters.getVenueLocationCrossStreetOrCity(
mStateHolder.getVenue()));
Button btn = (Button) findViewById(R.id.addTodoActivityButton);
btn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
EditText et = (EditText)findViewById(R.id.addTodoActivityText);
String text = et.getText().toString();
mStateHolder.startTaskAddTodo(AddTodoActivity.this, mStateHolder.getVenue().getId(), text);
}
});
if (mStateHolder.getIsRunningTaskVenue()) {
startProgressBar();
}
}
private void startProgressBar() {
if (mDlgProgress == null) {
mDlgProgress = ProgressDialog.show(this, "",
getResources().getString(R.string.add_tip_todo_activity_progress_message));
mDlgProgress.setCancelable(true);
mDlgProgress.setOnCancelListener(new OnCancelListener() {
@Override
public void onCancel(DialogInterface dialog) {
Log.e(TAG, "User cancelled add todo.");
mStateHolder.cancelTasks();
}
});
}
mDlgProgress.show();
setProgressBarIndeterminateVisibility(true);
}
private void stopProgressBar() {
if (mDlgProgress != null) {
mDlgProgress.dismiss();
mDlgProgress = null;
}
setProgressBarIndeterminateVisibility(false);
}
private static class TaskAddTodo extends AsyncTask<Void, Void, Todo> {
private AddTodoActivity mActivity;
private String mVenueId;
private String mTipText;
private Exception mReason;
public TaskAddTodo(AddTodoActivity activity, String venueId, String tipText) {
mActivity = activity;
mVenueId = venueId;
mTipText = tipText;
}
@Override
protected void onPreExecute() {
mActivity.startProgressBar();
}
@Override
protected Todo doInBackground(Void... params) {
try {
// If the user entered optional text, we need to use one endpoint,
// if not, we need to use mark/todo.
Foursquared foursquared = (Foursquared)mActivity.getApplication();
Todo todo = null;
if (!TextUtils.isEmpty(mTipText)) {
// The returned tip won't have the user object or venue attached to it
// as part of the response. The venue is the parent venue and the user
// is the logged-in user.
Tip tip = foursquared.getFoursquare().addTip(
mVenueId, mTipText, "todo",
LocationUtils.createFoursquareLocation(foursquared.getLastKnownLocation()));
// So fetch the full tip for convenience.
Tip tipFull = foursquared.getFoursquare().tipDetail(tip.getId());
// The addtip API returns a tip instead of a todo, unlike the mark/todo endpoint,
// so we create a dummy todo object for now to wrap the tip.
String now = StringFormatters.createServerDateFormatV1();
todo = new Todo();
todo.setId("id_" + now);
todo.setCreated(now);
todo.setTip(tipFull);
Log.i(TAG, "Added todo with wrapper ID: " + todo.getId());
} else {
// No text, so in this case we need to mark the venue itself as a todo.
todo = foursquared.getFoursquare().markTodoVenue(mVenueId);
Log.i(TAG, "Added todo with ID: " + todo.getId());
}
return todo;
} catch (Exception e) {
Log.e(TAG, "Error adding tip.", e);
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(Todo todo) {
mActivity.stopProgressBar();
mActivity.mStateHolder.setIsRunningTaskAddTip(false);
if (todo != null) {
Intent intent = new Intent();
intent.putExtra(EXTRA_TODO_RETURNED, todo);
mActivity.setResult(Activity.RESULT_OK, intent);
mActivity.finish();
} else {
NotificationsUtil.ToastReasonForFailure(mActivity, mReason);
mActivity.setResult(Activity.RESULT_CANCELED);
mActivity.finish();
}
}
@Override
protected void onCancelled() {
mActivity.stopProgressBar();
mActivity.setResult(Activity.RESULT_CANCELED);
mActivity.finish();
}
public void setActivity(AddTodoActivity activity) {
mActivity = activity;
}
}
private static final class StateHolder {
private Venue mVenue;
private TaskAddTodo mTaskAddTodo;
private boolean mIsRunningTaskAddTip;
public Venue getVenue() {
return mVenue;
}
public void setVenue(Venue venue) {
mVenue = venue;
}
public boolean getIsRunningTaskVenue() {
return mIsRunningTaskAddTip;
}
public void setIsRunningTaskAddTip(boolean isRunningTaskAddTip) {
mIsRunningTaskAddTip = isRunningTaskAddTip;
}
public void startTaskAddTodo(AddTodoActivity activity, String venueId, String text) {
mIsRunningTaskAddTip = true;
mTaskAddTodo = new TaskAddTodo(activity, venueId, text);
mTaskAddTodo.execute();
}
public void setActivityForTasks(AddTodoActivity activity) {
if (mTaskAddTodo != null) {
mTaskAddTodo.setActivity(activity);
}
}
public void cancelTasks() {
if (mTaskAddTodo != null) {
mTaskAddTodo.cancel(true);
}
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.app.LoadableListActivityWithViewAndHeader;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.util.NotificationsUtil;
import com.joelapenna.foursquared.util.UserUtils;
import com.joelapenna.foursquared.widget.FriendActionableListAdapter;
import com.joelapenna.foursquared.widget.SegmentedButton;
import com.joelapenna.foursquared.widget.SegmentedButton.OnClickListenerSegmentedButton;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.location.Location;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ScrollView;
import java.util.ArrayList;
import java.util.List;
/**
* Shows the logged-in user's followers and friends. If the user has no followers, then
* they should just be shown UserDetailsFriendsActivity directly.
*
* @date September 25, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class UserDetailsFriendsFollowersActivity extends LoadableListActivityWithViewAndHeader {
static final String TAG = "UserDetailsFriendsFollowersActivity";
static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String EXTRA_USER_NAME = Foursquared.PACKAGE_NAME
+ ".UserDetailsFriendsFollowersActivity.EXTRA_USER_NAME";
private StateHolder mStateHolder;
private FriendActionableListAdapter mListAdapter;
private ScrollView mLayoutEmpty;
private static final int MENU_REFRESH = 0;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivity(this);
} else {
if (getIntent().hasExtra(EXTRA_USER_NAME)) {
mStateHolder = new StateHolder(getIntent().getStringExtra(EXTRA_USER_NAME));
mStateHolder.setFollowersOnly(true);
} else {
Log.e(TAG, TAG + " requires user name in intent extras.");
finish();
return;
}
}
ensureUi();
// Friend tips is shown first by default so auto-fetch it if necessary.
if (!mStateHolder.getRanOnceFollowers()) {
mStateHolder.startTask(this, true);
}
}
@Override
public void onPause() {
super.onPause();
if (isFinishing()) {
mStateHolder.cancelTasks();
mListAdapter.removeObserver();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivity(null);
return mStateHolder;
}
private void ensureUi() {
LayoutInflater inflater = LayoutInflater.from(this);
mLayoutEmpty = (ScrollView)inflater.inflate(R.layout.user_details_friends_activity_empty, null);
mLayoutEmpty.setLayoutParams(new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.FILL_PARENT, LinearLayout.LayoutParams.FILL_PARENT));
mListAdapter = new FriendActionableListAdapter(
this, mButtonRowClickHandler, ((Foursquared) getApplication()).getRemoteResourceManager());
if (mStateHolder.getFollowersOnly()) {
mListAdapter.setGroup(mStateHolder.getFollowers());
if (mStateHolder.getFollowers().size() == 0) {
if (mStateHolder.getRanOnceFollowers()) {
setEmptyView(mLayoutEmpty);
} else {
setLoadingView();
}
}
} else {
mListAdapter.setGroup(mStateHolder.getFriends());
if (mStateHolder.getFriends().size() == 0) {
if (mStateHolder.getRanOnceFriends()) {
setEmptyView(mLayoutEmpty);
} else {
setLoadingView();
}
}
}
SegmentedButton buttons = getHeaderButton();
buttons.clearButtons();
buttons.addButtons(
getString(R.string.user_details_friends_followers_activity_followers),
getString(R.string.user_details_friends_followers_activity_friends));
if (mStateHolder.mFollowersOnly) {
buttons.setPushedButtonIndex(0);
} else {
buttons.setPushedButtonIndex(1);
}
buttons.setOnClickListener(new OnClickListenerSegmentedButton() {
@Override
public void onClick(int index) {
if (index == 0) {
mStateHolder.setFollowersOnly(true);
mListAdapter.setGroup(mStateHolder.getFollowers());
if (mStateHolder.getFollowers().size() < 1) {
if (mStateHolder.getRanOnceFollowers()) {
setEmptyView(mLayoutEmpty);
} else {
setLoadingView();
mStateHolder.startTask(UserDetailsFriendsFollowersActivity.this, true);
}
}
} else {
mStateHolder.setFollowersOnly(false);
mListAdapter.setGroup(mStateHolder.getFriends());
if (mStateHolder.getFriends().size() < 1) {
if (mStateHolder.getRanOnceFriends()) {
setEmptyView(mLayoutEmpty);
} else {
setLoadingView();
mStateHolder.startTask(UserDetailsFriendsFollowersActivity.this, false);
}
}
}
mListAdapter.notifyDataSetChanged();
getListView().setSelection(0);
}
});
ListView listView = getListView();
listView.setAdapter(mListAdapter);
listView.setSmoothScrollbarEnabled(false);
listView.setItemsCanFocus(false);
listView.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
User user = (User) parent.getAdapter().getItem(position);
Intent intent = new Intent(UserDetailsFriendsFollowersActivity.this, UserDetailsActivity.class);
intent.putExtra(UserDetailsActivity.EXTRA_USER_PARCEL, user);
startActivity(intent);
}
});
if (mStateHolder.getIsRunningTaskFollowers() ||
mStateHolder.getIsRunningTaskFriends()) {
setProgressBarIndeterminateVisibility(true);
} else {
setProgressBarIndeterminateVisibility(false);
}
setTitle(getString(R.string.user_details_friends_followers_activity_title,
mStateHolder.getUsername()));
}
private FriendActionableListAdapter.ButtonRowClickHandler mButtonRowClickHandler =
new FriendActionableListAdapter.ButtonRowClickHandler() {
@Override
public void onBtnClickBtn1(User user) {
if (mStateHolder.getFollowersOnly()) {
updateFollowerStatus(user, true);
}
}
@Override
public void onBtnClickBtn2(User user) {
if (mStateHolder.getFollowersOnly()) {
updateFollowerStatus(user, false);
}
}
};
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
menu.add(Menu.NONE, MENU_REFRESH, Menu.NONE, R.string.refresh)
.setIcon(R.drawable.ic_menu_refresh);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_REFRESH:
mStateHolder.startTask(this, mStateHolder.getFollowersOnly());
return true;
}
return super.onOptionsItemSelected(item);
}
/*
* Leaving this out for now as it may be very costly for users with very large
* friend networks.
private void prepareResultIntent() {
Group<User> followers = mStateHolder.getFollowers();
Group<User> friends = mStateHolder.getFollowers();
User[] followersArr = (User[])followers.toArray(new User[followers.size()]);
User[] friendsArr = (User[])friends.toArray(new User[friends.size()]);
Intent intent = new Intent();
intent.putExtra(EXTRA_FOLLOWERS_RETURNED, followersArr);
intent.putExtra(EXTRA_FRIENDS_RETURNED, friendsArr);
setResult(CODE, intent);
}
*/
private void updateFollowerStatus(User user, boolean approve) {
mStateHolder.startTaskUpdateFollower(this, user, approve);
if (mStateHolder.getFollowersOnly()) {
mListAdapter.notifyDataSetChanged();
if (mStateHolder.getFollowers().size() == 0) {
setEmptyView(mLayoutEmpty);
}
}
}
private void onStartTaskUsers() {
if (mListAdapter != null) {
if (mStateHolder.getFollowersOnly()) {
mStateHolder.setIsRunningTaskFollowers(true);
mListAdapter.setGroup(mStateHolder.getFollowers());
} else {
mStateHolder.setIsRunningTaskFriends(true);
mListAdapter.setGroup(mStateHolder.getFriends());
}
mListAdapter.notifyDataSetChanged();
}
setProgressBarIndeterminateVisibility(true);
setLoadingView();
}
private void onStartUpdateFollower() {
setProgressBarIndeterminateVisibility(true);
}
private void onTaskUsersComplete(Group<User> group, boolean friendsOnly, Exception ex) {
SegmentedButton buttons = getHeaderButton();
boolean update = false;
if (group != null) {
if (friendsOnly) {
mStateHolder.setFollowers(group);
if (buttons.getSelectedButtonIndex() == 0) {
mListAdapter.setGroup(mStateHolder.getFollowers());
update = true;
}
} else {
mStateHolder.setFriends(group);
if (buttons.getSelectedButtonIndex() == 1) {
mListAdapter.setGroup(mStateHolder.getFriends());
update = true;
}
}
}
else {
if (friendsOnly) {
mStateHolder.setFollowers(new Group<User>());
if (buttons.getSelectedButtonIndex() == 0) {
mListAdapter.setGroup(mStateHolder.getFollowers());
update = true;
}
} else {
mStateHolder.setFriends(new Group<User>());
if (buttons.getSelectedButtonIndex() == 1) {
mListAdapter.setGroup(mStateHolder.getFriends());
update = true;
}
}
NotificationsUtil.ToastReasonForFailure(this, ex);
}
if (friendsOnly) {
mStateHolder.setIsRunningTaskFollowers(false);
mStateHolder.setRanOnceFollowers(true);
if (mStateHolder.getFollowers().size() == 0 &&
buttons.getSelectedButtonIndex() == 0) {
setEmptyView(mLayoutEmpty);
}
} else {
mStateHolder.setIsRunningTaskFriends(false);
mStateHolder.setRanOnceFriends(true);
if (mStateHolder.getFriends().size() == 0 &&
buttons.getSelectedButtonIndex() == 1) {
setEmptyView(mLayoutEmpty);
}
}
if (update) {
mListAdapter.notifyDataSetChanged();
getListView().setSelection(0);
}
if (!mStateHolder.areAnyTasksRunning()) {
setProgressBarIndeterminateVisibility(false);
}
}
private void onTaskUpdateFollowerComplete(TaskUpdateFollower task, User user,
boolean approve, Exception ex) {
if (user != null) {
if (UserUtils.isFriend(user)) {
if (mStateHolder.addFriend(user)) {
mListAdapter.notifyDataSetChanged();
}
}
}
mStateHolder.removeTaskUpdateFollower(task);
if (!mStateHolder.areAnyTasksRunning()) {
setProgressBarIndeterminateVisibility(false);
}
}
private static class TaskUsers extends AsyncTask<Void, Void, Group<User>> {
private UserDetailsFriendsFollowersActivity mActivity;
private boolean mFollowersOnly;
private Exception mReason;
public TaskUsers(UserDetailsFriendsFollowersActivity activity, boolean followersOnly) {
mActivity = activity;
mFollowersOnly = followersOnly;
}
@Override
protected void onPreExecute() {
mActivity.onStartTaskUsers();
}
@Override
protected Group<User> doInBackground(Void... params) {
try {
Foursquared foursquared = (Foursquared) mActivity.getApplication();
Foursquare foursquare = foursquared.getFoursquare();
Location loc = foursquared.getLastKnownLocation();
if (mFollowersOnly) {
return foursquare.friendRequests();
} else {
return foursquare.friends(null, LocationUtils.createFoursquareLocation(loc));
}
} catch (Exception e) {
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(Group<User> users) {
if (mActivity != null) {
mActivity.onTaskUsersComplete(users, mFollowersOnly, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onTaskUsersComplete(null, mFollowersOnly, mReason);
}
}
public void setActivity(UserDetailsFriendsFollowersActivity activity) {
mActivity = activity;
}
}
private static class TaskUpdateFollower extends AsyncTask<Void, Void, User> {
private UserDetailsFriendsFollowersActivity mActivity;
private String mUserId;
private boolean mApprove;
private Exception mReason;
private boolean mDone;
public TaskUpdateFollower(UserDetailsFriendsFollowersActivity activity,
String userId,
boolean approve) {
mActivity = activity;
mUserId = userId;
mApprove = approve;
mDone = false;
}
@Override
protected void onPreExecute() {
mActivity.onStartUpdateFollower();
}
@Override
protected User doInBackground(Void... params) {
try {
Foursquared foursquared = (Foursquared) mActivity.getApplication();
Foursquare foursquare = foursquared.getFoursquare();
if (mApprove) {
return foursquare.friendApprove(mUserId);
} else {
return foursquare.friendDeny(mUserId);
}
} catch (Exception e) {
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(User user) {
if (mActivity != null) {
mActivity.onTaskUpdateFollowerComplete(this, user, mApprove, mReason);
}
mDone = true;
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onTaskUpdateFollowerComplete(this, null, mApprove, mReason);
}
mDone = true;
}
public void setActivity(UserDetailsFriendsFollowersActivity activity) {
mActivity = activity;
}
public boolean getIsDone() {
return mDone;
}
}
private static class StateHolder {
private String mUsername;
private Group<User> mFollowers;
private Group<User> mFriends;
private TaskUsers mTaskFollowers;
private TaskUsers mTaskFriends;
private boolean mIsRunningTaskFollowers;
private boolean mIsRunningTaskFriends;
private boolean mFollowersOnly;
private boolean mRanOnceFollowers;
private boolean mRanOnceFriends;
private List<TaskUpdateFollower> mTasksUpdateFollowers;
public StateHolder(String username) {
mUsername = username;
mIsRunningTaskFollowers = false;
mIsRunningTaskFriends = false;
mRanOnceFriends = false;
mRanOnceFollowers = false;
mFollowers = new Group<User>();
mFriends = new Group<User>();
mFollowersOnly = true;
mTasksUpdateFollowers = new ArrayList<TaskUpdateFollower>();
}
public String getUsername() {
return mUsername;
}
public Group<User> getFollowers() {
return mFollowers;
}
public void setFollowers(Group<User> followers) {
mFollowers = followers;
}
public Group<User> getFriends() {
return mFriends;
}
public void setFriends(Group<User> friends) {
mFriends = friends;
}
public void startTask(UserDetailsFriendsFollowersActivity activity,
boolean followersOnly) {
if (followersOnly) {
if (mIsRunningTaskFollowers) {
return;
}
mIsRunningTaskFollowers = true;
mTaskFollowers = new TaskUsers(activity, followersOnly);
mTaskFollowers.execute();
} else {
if (mIsRunningTaskFriends) {
return;
}
mIsRunningTaskFriends = true;
mTaskFriends = new TaskUsers(activity, followersOnly);
mTaskFriends.execute();
}
}
public void startTaskUpdateFollower(UserDetailsFriendsFollowersActivity activity,
User user,
boolean approve) {
for (User it : mFollowers) {
if (it.getId().equals(user.getId())) {
mFollowers.remove(it);
break;
}
}
TaskUpdateFollower task = new TaskUpdateFollower(activity, user.getId(), approve);
task.execute();
mTasksUpdateFollowers.add(task);
}
public void setActivity(UserDetailsFriendsFollowersActivity activity) {
if (mTaskFollowers != null) {
mTaskFollowers.setActivity(activity);
}
if (mTaskFriends != null) {
mTaskFriends.setActivity(activity);
}
for (TaskUpdateFollower it : mTasksUpdateFollowers) {
it.setActivity(activity);
}
}
public boolean getIsRunningTaskFollowers() {
return mIsRunningTaskFollowers;
}
public void setIsRunningTaskFollowers(boolean isRunning) {
mIsRunningTaskFollowers = isRunning;
}
public boolean getIsRunningTaskFriends() {
return mIsRunningTaskFriends;
}
public void setIsRunningTaskFriends(boolean isRunning) {
mIsRunningTaskFriends = isRunning;
}
public void cancelTasks() {
if (mTaskFollowers != null) {
mTaskFollowers.setActivity(null);
mTaskFollowers.cancel(true);
}
if (mTaskFriends != null) {
mTaskFriends.setActivity(null);
mTaskFriends.cancel(true);
}
for (TaskUpdateFollower it : mTasksUpdateFollowers) {
it.setActivity(null);
it.cancel(true);
}
}
public boolean getFollowersOnly() {
return mFollowersOnly;
}
public void setFollowersOnly(boolean followersOnly) {
mFollowersOnly = followersOnly;
}
public boolean getRanOnceFollowers() {
return mRanOnceFollowers;
}
public void setRanOnceFollowers(boolean ranOnce) {
mRanOnceFollowers = ranOnce;
}
public boolean getRanOnceFriends() {
return mRanOnceFriends;
}
public void setRanOnceFriends(boolean ranOnce) {
mRanOnceFriends = ranOnce;
}
public boolean areAnyTasksRunning() {
return mIsRunningTaskFollowers || mIsRunningTaskFriends
|| mTasksUpdateFollowers.size() > 0;
}
public boolean addFriend(User user) {
for (User it : mFriends) {
if (it.getId().equals(user.getId())) {
return false;
}
}
mFriends.add(user);
return true;
}
public void removeTaskUpdateFollower(TaskUpdateFollower task) {
mTasksUpdateFollowers.remove(task);
// Try to cleanup anyone we missed, this could happen for a brief period
// during rotation.
for (int i = mTasksUpdateFollowers.size()-1; i > -1; i--) {
if (mTasksUpdateFollowers.get(i).getIsDone()) {
mTasksUpdateFollowers.remove(i);
}
}
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
/**
* Presents the user with a list of different methods for adding foursquare
* friends.
*
* @date February 11, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public class AddFriendsActivity extends Activity {
private static final String TAG = "AddFriendsActivity";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (DEBUG) Log.d(TAG, "onCreate()");
setContentView(R.layout.add_friends_activity);
Button btnAddFriendsByAddressBook = (Button) findViewById(R.id.findFriendsByAddressBook);
btnAddFriendsByAddressBook.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(AddFriendsActivity.this,
AddFriendsByUserInputActivity.class);
intent.putExtra(AddFriendsByUserInputActivity.INPUT_TYPE,
AddFriendsByUserInputActivity.INPUT_TYPE_ADDRESSBOOK);
startActivity(intent);
}
});
Button btnAddFriendsByFacebook = (Button) findViewById(R.id.findFriendsByFacebook);
btnAddFriendsByFacebook.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(AddFriendsActivity.this,
AddFriendsByUserInputActivity.class);
intent.putExtra(AddFriendsByUserInputActivity.INPUT_TYPE,
AddFriendsByUserInputActivity.INPUT_TYPE_FACEBOOK);
startActivity(intent);
}
});
Button btnAddFriendsByTwitter = (Button) findViewById(R.id.findFriendsByTwitter);
btnAddFriendsByTwitter.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(AddFriendsActivity.this,
AddFriendsByUserInputActivity.class);
intent.putExtra(AddFriendsByUserInputActivity.INPUT_TYPE,
AddFriendsByUserInputActivity.INPUT_TYPE_TWITTERNAME);
startActivity(intent);
}
});
Button btnAddFriendsByName = (Button) findViewById(R.id.findFriendsByNameOrPhoneNumber);
btnAddFriendsByName.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(AddFriendsActivity.this,
AddFriendsByUserInputActivity.class);
intent.putExtra(AddFriendsByUserInputActivity.INPUT_TYPE,
AddFriendsByUserInputActivity.INPUT_TYPE_NAME_OR_PHONE);
startActivity(intent);
}
});
Button btnInviteFriends = (Button) findViewById(R.id.findFriendsInvite);
btnInviteFriends.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(AddFriendsActivity.this,
AddFriendsByUserInputActivity.class);
intent.putExtra(AddFriendsByUserInputActivity.INPUT_TYPE,
AddFriendsByUserInputActivity.INPUT_TYPE_ADDRESSBOOK_INVITE);
startActivity(intent);
}
});
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.error.LocationException;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.providers.VenueQuerySuggestionsProvider;
import com.joelapenna.foursquared.util.Comparators;
import com.joelapenna.foursquared.util.NotificationsUtil;
import com.joelapenna.foursquared.util.TabsUtil;
import com.joelapenna.foursquared.util.UiUtil;
import com.joelapenna.foursquared.widget.SeparatedListAdapter;
import com.joelapenna.foursquared.widget.VenueListAdapter;
import android.app.Activity;
import android.app.SearchManager;
import android.app.TabActivity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.location.Location;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Parcelable;
import android.provider.SearchRecentSuggestions;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.TabHost;
import android.widget.TextView;
import android.widget.Toast;
import java.io.IOException;
import java.util.Collections;
import java.util.Observable;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class SearchVenuesActivity extends TabActivity {
static final String TAG = "SearchVenuesActivity";
static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String QUERY_NEARBY = null;
public static SearchResultsObservable searchResultsObservable;
private static final int MENU_SEARCH = 0;
private static final int MENU_REFRESH = 1;
private static final int MENU_NEARBY = 2;
private static final int MENU_ADD_VENUE = 3;
private static final int MENU_GROUP_SEARCH = 0;
private SearchTask mSearchTask;
private SearchHolder mSearchHolder = new SearchHolder();
private ListView mListView;
private LinearLayout mEmpty;
private TextView mEmptyText;
private ProgressBar mEmptyProgress;
private TabHost mTabHost;
private SeparatedListAdapter mListAdapter;
private boolean mIsShortcutPicker;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.search_venues_activity);
setDefaultKeyMode(Activity.DEFAULT_KEYS_SEARCH_LOCAL);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
searchResultsObservable = new SearchResultsObservable();
initTabHost();
initListViewAdapter();
// Watch to see if we've been called as a shortcut intent.
mIsShortcutPicker = Intent.ACTION_CREATE_SHORTCUT.equals(getIntent().getAction());
if (getLastNonConfigurationInstance() != null) {
if (DEBUG) Log.d(TAG, "Restoring state.");
SearchHolder holder = (SearchHolder) getLastNonConfigurationInstance();
if (holder.results != null) {
mSearchHolder.query = holder.query;
setSearchResults(holder.results);
putSearchResultsInAdapter(holder.results);
}
} else {
onNewIntent(getIntent());
}
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
@Override
public void onResume() {
super.onResume();
((Foursquared) getApplication()).requestLocationUpdates(true);
if (mSearchHolder.results == null && mSearchTask == null) {
mSearchTask = (SearchTask) new SearchTask().execute();
}
}
@Override
public void onPause() {
super.onPause();
((Foursquared) getApplication()).removeLocationUpdates();
if (isFinishing()) {
mListAdapter.removeObserver();
}
}
@Override
public void onStop() {
super.onStop();
if (mSearchTask != null) {
mSearchTask.cancel(true);
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
// Always show these.
menu.add(MENU_GROUP_SEARCH, MENU_SEARCH, Menu.NONE, R.string.search_label) //
.setIcon(R.drawable.ic_menu_search) //
.setAlphabeticShortcut(SearchManager.MENU_KEY);
menu.add(MENU_GROUP_SEARCH, MENU_NEARBY, Menu.NONE, R.string.nearby_label) //
.setIcon(R.drawable.ic_menu_places);
menu.add(MENU_GROUP_SEARCH, MENU_REFRESH, Menu.NONE, R.string.refresh) //
.setIcon(R.drawable.ic_menu_refresh);
menu.add(MENU_GROUP_SEARCH, MENU_ADD_VENUE, Menu.NONE, R.string.nearby_menu_add_venue) //
.setIcon(R.drawable.ic_menu_add);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_SEARCH:
onSearchRequested();
return true;
case MENU_NEARBY:
executeSearchTask(null);
return true;
case MENU_REFRESH:
executeSearchTask(mSearchHolder.query);
return true;
case MENU_ADD_VENUE:
Intent intent = new Intent(SearchVenuesActivity.this, AddVenueActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP);
startActivity(intent);
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public void onNewIntent(Intent intent) {
if (intent != null) {
String action = intent.getAction();
String query = intent.getStringExtra(SearchManager.QUERY);
Log.i(TAG, "New Intent: action[" + action + "].");
if (!TextUtils.isEmpty(action)) {
if (action.equals(Intent.ACTION_CREATE_SHORTCUT)) {
Log.i(TAG, " action = create shortcut, user can click one of the current venues.");
} else if (action.equals(Intent.ACTION_VIEW)) {
if (!TextUtils.isEmpty(query)) {
Log.i(TAG, " action = view, query term provided, prepopulating search.");
startSearch(query, false, null, false);
} else {
Log.i(TAG, " action = view, but no query term provided, doing nothing.");
}
} else if (action.equals(Intent.ACTION_SEARCH) && !TextUtils.isEmpty(query)) {
Log.i(TAG, " action = search, query term provided, executing search immediately.");
SearchRecentSuggestions suggestions = new SearchRecentSuggestions(this,
VenueQuerySuggestionsProvider.AUTHORITY, VenueQuerySuggestionsProvider.MODE);
suggestions.saveRecentQuery(query, null);
executeSearchTask(query);
}
}
}
}
@Override
public Object onRetainNonConfigurationInstance() {
return mSearchHolder;
}
public void putSearchResultsInAdapter(Group<Group<Venue>> searchResults) {
mListAdapter.removeObserver();
mListAdapter = new SeparatedListAdapter(this);
int groupCount = searchResults.size();
for (int groupsIndex = 0; groupsIndex < groupCount; groupsIndex++) {
Group<Venue> group = searchResults.get(groupsIndex);
if (group.size() > 0) {
VenueListAdapter groupAdapter = new VenueListAdapter(this,
((Foursquared) getApplication()).getRemoteResourceManager());
groupAdapter.setGroup(group);
if (DEBUG) Log.d(TAG, "Adding Section: " + group.getType());
mListAdapter.addSection(group.getType(), groupAdapter);
}
}
mListView.setAdapter(mListAdapter);
}
public void setSearchResults(Group<Group<Venue>> searchResults) {
if (DEBUG) Log.d(TAG, "Setting search results.");
mSearchHolder.results = searchResults;
searchResultsObservable.notifyObservers();
}
void executeSearchTask(String query) {
if (DEBUG) Log.d(TAG, "sendQuery()");
mSearchHolder.query = query;
// not going through set* because we don't want to notify search result
// observers.
mSearchHolder.results = null;
// If a task is already running, don't start a new one.
if (mSearchTask != null && mSearchTask.getStatus() != AsyncTask.Status.FINISHED) {
if (DEBUG) Log.d(TAG, "Query already running attempting to cancel: " + mSearchTask);
if (!mSearchTask.cancel(true) && !mSearchTask.isCancelled()) {
if (DEBUG) Log.d(TAG, "Unable to cancel search? Notifying the user.");
Toast.makeText(this, getString(R.string.search_already_in_progress_toast),
Toast.LENGTH_SHORT);
return;
}
}
mSearchTask = (SearchTask) new SearchTask().execute();
}
void startItemActivity(Venue venue) {
Intent intent = new Intent(SearchVenuesActivity.this, VenueActivity.class);
intent.setAction(Intent.ACTION_VIEW);
intent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_PARTIAL, venue);
startActivity(intent);
}
private void ensureSearchResults() {
if (mListAdapter.getCount() > 0) {
mEmpty.setVisibility(LinearLayout.GONE);
mListView.setVisibility(ViewGroup.VISIBLE);
} else {
mEmpty.setVisibility(LinearLayout.VISIBLE);
mEmptyProgress.setVisibility(ViewGroup.GONE);
mEmptyText.setText(R.string.no_search_results);
mListView.setVisibility(ViewGroup.GONE);
}
}
private void ensureTitle(boolean finished) {
if (finished) {
if (mSearchHolder.query == QUERY_NEARBY) {
setTitle(getString(R.string.title_search_finished_noquery));
} else {
setTitle(getString(R.string.title_search_finished, mSearchHolder.query));
}
} else {
if (mSearchHolder.query == QUERY_NEARBY) {
setTitle(getString(R.string.title_search_inprogress_noquery));
} else {
setTitle(getString(R.string.title_search_inprogress, mSearchHolder.query));
}
}
}
private void initListViewAdapter() {
if (mListView != null) {
throw new IllegalStateException("Trying to initialize already initialized ListView");
}
mEmpty = (LinearLayout) findViewById(R.id.empty);
mEmptyText = (TextView) findViewById(R.id.emptyText);
mEmptyProgress = (ProgressBar) findViewById(R.id.emptyProgress);
mListView = (ListView) findViewById(R.id.list);
mListAdapter = new SeparatedListAdapter(this);
mListView.setAdapter(mListAdapter);
mListView.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
Venue venue = (Venue) parent.getAdapter().getItem(position);
if (mIsShortcutPicker) {
setupShortcut(venue);
finish();
} else {
startItemActivity(venue);
}
finish();
}
});
}
protected void setupShortcut(Venue venue) {
// First, set up the shortcut intent. For this example, we simply create
// an intent that will bring us directly back to this activity. A more
// typical implementation would use a data Uri in order to display a more
// specific result, or a custom action in order to launch a specific operation.
Intent shortcutIntent = new Intent(Intent.ACTION_MAIN);
shortcutIntent.setClassName(this, VenueActivity.class.getName());
shortcutIntent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_ID, venue.getId());
// Then, set up the container intent (the response to the caller)
Intent intent = new Intent();
intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, venue.getName());
Parcelable iconResource = Intent.ShortcutIconResource.fromContext(this,
R.drawable.venue_shortcut_icon);
intent.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, iconResource);
// Now, return the result to the launcher
setResult(RESULT_OK, intent);
}
private void initTabHost() {
if (mTabHost != null) {
throw new IllegalStateException("Trying to intialize already initializd TabHost");
}
mTabHost = getTabHost();
TabsUtil.addTab(mTabHost, getString(R.string.tab_search_nav_venues),
R.drawable.tab_search_nav_venues_selector, 0, R.id.listviewLayout);
TabsUtil.addTab(mTabHost, getString(R.string.tab_search_nav_map),
R.drawable.tab_search_nav_map_selector,
1, new Intent(this, SearchVenuesMapActivity.class));
mTabHost.setCurrentTab(0);
// Fix layout for 1.5.
if (UiUtil.sdkVersion() < 4) {
FrameLayout flTabContent = (FrameLayout)findViewById(android.R.id.tabcontent);
flTabContent.setPadding(0, 0, 0, 0);
}
}
private class SearchTask extends AsyncTask<Void, Void, Group<Group<Venue>>> {
private Exception mReason = null;
@Override
public void onPreExecute() {
if (DEBUG) Log.d(TAG, "SearchTask: onPreExecute()");
setProgressBarIndeterminateVisibility(true);
ensureTitle(false);
}
@Override
public Group<Group<Venue>> doInBackground(Void... params) {
try {
return search();
} catch (Exception e) {
mReason = e;
}
return null;
}
@Override
public void onPostExecute(Group<Group<Venue>> groups) {
try {
if (groups == null) {
NotificationsUtil.ToastReasonForFailure(SearchVenuesActivity.this, mReason);
} else {
setSearchResults(groups);
putSearchResultsInAdapter(groups);
}
} finally {
setProgressBarIndeterminateVisibility(false);
ensureTitle(true);
ensureSearchResults();
}
}
public Group<Group<Venue>> search() throws FoursquareException, LocationException,
IOException {
Foursquare foursquare = ((Foursquared) getApplication()).getFoursquare();
Location location = ((Foursquared) getApplication()).getLastKnownLocationOrThrow();
Group<Group<Venue>> groups = foursquare.venues(LocationUtils
.createFoursquareLocation(location), mSearchHolder.query, 30);
for (int i = 0; i < groups.size(); i++) {
Collections.sort(groups.get(i), Comparators.getVenueDistanceComparator());
}
return groups;
}
}
private static class SearchHolder {
Group<Group<Venue>> results;
String query;
}
class SearchResultsObservable extends Observable {
@Override
public void notifyObservers(Object data) {
setChanged();
super.notifyObservers(data);
}
public Group<Group<Venue>> getSearchResults() {
return mSearchHolder.results;
}
public String getQuery() {
return mSearchHolder.query;
}
};
}
| Java |
/**
* Copyright 2010 Tauno Talimaa
*/
package com.joelapenna.foursquared.providers;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareError;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.Foursquared;
import com.joelapenna.foursquared.FoursquaredSettings;
import com.joelapenna.foursquared.error.LocationException;
import com.joelapenna.foursquared.location.BestLocationListener;
import com.joelapenna.foursquared.location.LocationUtils;
import android.app.SearchManager;
import android.content.ContentProvider;
import android.content.ContentValues;
import android.content.Context;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.location.Location;
import android.location.LocationManager;
import android.net.Uri;
import android.util.Log;
import java.io.IOException;
/**
* A ContentProvider for Foursquare search results.
*
* @author Tauno Talimaa (tauntz@gmail.com)
*/
public class GlobalSearchProvider extends ContentProvider {
// TODO: Implement search for friends by name/phone number/twitter ID when
// API is implemented in Foursquare.java
private static final String TAG = GlobalSearchProvider.class.getSimpleName();
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private static final String[] QSB_COLUMNS = {
"_id", SearchManager.SUGGEST_COLUMN_ICON_1, SearchManager.SUGGEST_COLUMN_TEXT_1,
SearchManager.SUGGEST_COLUMN_TEXT_2, SearchManager.SUGGEST_COLUMN_QUERY,
SearchManager.SUGGEST_COLUMN_SHORTCUT_ID,
SearchManager.SUGGEST_COLUMN_SPINNER_WHILE_REFRESHING,
SearchManager.SUGGEST_COLUMN_INTENT_DATA, SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID
};
private static final int URI_TYPE_QUERY = 1;
private static final int URI_TYPE_SHORTCUT = 2;
private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
static {
sUriMatcher.addURI(Foursquared.PACKAGE_NAME, SearchManager.SUGGEST_URI_PATH_QUERY + "/*",
URI_TYPE_QUERY);
sUriMatcher.addURI(Foursquared.PACKAGE_NAME,
SearchManager.SUGGEST_URI_PATH_SHORTCUT + "/*", URI_TYPE_SHORTCUT);
}
public static final String VENUE_DIRECTORY = "venue";
public static final String FRIEND_DIRECTORY = "friend";
// TODO: Use the argument from SUGGEST_PARAMETER_LIMIT from the Uri passed
// to query() instead of the hardcoded value (this is available starting
// from API level 5)
private static final int VENUE_QUERY_LIMIT = 30;
private Foursquare mFoursquare;
@Override
public boolean onCreate() {
synchronized (this) {
if (mFoursquare == null) mFoursquare = Foursquared.createFoursquare(getContext());
}
return true;
}
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) {
String query = uri.getLastPathSegment();
MatrixCursor cursor = new MatrixCursor(QSB_COLUMNS);
switch (sUriMatcher.match(uri)) {
case URI_TYPE_QUERY:
if (DEBUG) {
Log.d(TAG, "Global search for venue name: " + query);
}
Group<Group<Venue>> venueGroups;
try {
venueGroups = mFoursquare.venues(LocationUtils
.createFoursquareLocation(getBestRecentLocation()), query,
VENUE_QUERY_LIMIT);
} catch (FoursquareError e) {
if (DEBUG) Log.e(TAG, "Could not get venue list for query: " + query, e);
return cursor;
} catch (FoursquareException e) {
if (DEBUG) Log.w(TAG, "Could not get venue list for query: " + query, e);
return cursor;
} catch (LocationException e) {
if (DEBUG) Log.w(TAG, "Could not retrieve a recent location", e);
return cursor;
} catch (IOException e) {
if (DEBUG) Log.w(TAG, "Could not get venue list for query: " + query, e);
return cursor;
}
for (int groupIndex = 0; groupIndex < venueGroups.size(); groupIndex++) {
Group<Venue> venueGroup = venueGroups.get(groupIndex);
if (DEBUG) {
Log.d(TAG, venueGroup.size() + " results for group: "
+ venueGroup.getType());
}
for (int venueIndex = 0; venueIndex < venueGroup.size(); venueIndex++) {
Venue venue = venueGroup.get(venueIndex);
if (DEBUG) {
Log.d(TAG, "Venue " + venueIndex + ": " + venue.getName() + " ("
+ venue.getAddress() + ")");
}
cursor.addRow(new Object[] {
venue.getId(),
com.joelapenna.foursquared.R.drawable.venue_shortcut_icon,
venue.getName(), venue.getAddress(), venue.getName(),
venue.getId(), "true", VENUE_DIRECTORY, venue.getId()
});
}
}
break;
case URI_TYPE_SHORTCUT:
if (DEBUG) {
Log.d(TAG, "Global search for venue ID: " + query);
}
Venue venue;
try {
venue = mFoursquare.venue(query, LocationUtils
.createFoursquareLocation(getBestRecentLocation()));
} catch (FoursquareError e) {
if (DEBUG) Log.e(TAG, "Could not get venue details for venue ID: " + query, e);
return cursor;
} catch (LocationException e) {
if (DEBUG) Log.w(TAG, "Could not retrieve a recent location", e);
return cursor;
} catch (FoursquareException e) {
if (DEBUG) Log.w(TAG, "Could not get venue details for venue ID: " + query, e);
return cursor;
} catch (IOException e) {
if (DEBUG) Log.w(TAG, "Could not get venue details for venue ID: " + query, e);
return cursor;
}
if (DEBUG) {
Log.d(TAG, "Updated venue details: " + venue.getName() + " ("
+ venue.getAddress() + ")");
}
cursor.addRow(new Object[] {
venue.getId(), com.joelapenna.foursquared.R.drawable.venue_shortcut_icon,
venue.getName(), venue.getAddress(), venue.getName(), venue.getId(),
"true", VENUE_DIRECTORY, venue.getId()
});
break;
case UriMatcher.NO_MATCH:
if (DEBUG) {
Log.d(TAG, "No matching URI for: " + uri);
}
break;
}
return cursor;
}
@Override
public String getType(Uri uri) {
return SearchManager.SUGGEST_MIME_TYPE;
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
throw new UnsupportedOperationException();
}
@Override
public Uri insert(Uri uri, ContentValues values) {
throw new UnsupportedOperationException();
}
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
throw new UnsupportedOperationException();
}
/**
* Convenience method for getting the most recent Location
*
* @return the most recent Locations
* @throws LocationException when no recent Location could be determined
*/
private Location getBestRecentLocation() throws LocationException {
BestLocationListener locationListener = new BestLocationListener();
locationListener.updateLastKnownLocation((LocationManager) getContext().getSystemService(
Context.LOCATION_SERVICE));
Location location = locationListener.getLastKnownLocation();
if (location != null) {
return location;
}
throw new LocationException();
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared.providers;
import android.content.SearchRecentSuggestionsProvider;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class VenueQuerySuggestionsProvider extends SearchRecentSuggestionsProvider {
public static final String AUTHORITY = "com.joelapenna.foursquared.providers.VenueQuerySuggestionsProvider";
public static final int MODE = DATABASE_MODE_QUERIES;
public VenueQuerySuggestionsProvider() {
super();
setupSuggestions(AUTHORITY, MODE);
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import android.content.Intent;
import android.location.Location;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Toast;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapActivity;
import com.google.android.maps.MapController;
import com.google.android.maps.MapView;
import com.google.android.maps.MyLocationOverlay;
import com.google.android.maps.OverlayItem;
import com.joelapenna.foursquare.types.Checkin;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquare.util.VenueUtils;
import com.joelapenna.foursquared.maps.CheckinGroup;
import com.joelapenna.foursquared.maps.CheckinGroupItemizedOverlay;
import com.joelapenna.foursquared.maps.CheckinGroupItemizedOverlay.CheckinGroupOverlayTapListener;
import com.joelapenna.foursquared.maps.CrashFixMyLocationOverlay;
import com.joelapenna.foursquared.util.CheckinTimestampSort;
import com.joelapenna.foursquared.util.GeoUtils;
import com.joelapenna.foursquared.util.UiUtil;
import com.joelapenna.foursquared.widget.MapCalloutView;
/**
* @author Joe LaPenna (joe@joelapenna.com)
* @author Mark Wyszomierski (markww@gmail.com)
* -Added support for checkingroup items, also stopped recreation
* of overlay group in onResume(). [2010-06-21]
*/
public class FriendsMapActivity extends MapActivity {
public static final String TAG = "FriendsMapActivity";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String EXTRA_CHECKIN_PARCELS = Foursquared.PACKAGE_NAME
+ ".FriendsMapActivity.EXTRA_CHECKIN_PARCELS";
private StateHolder mStateHolder;
private Venue mTappedVenue;
private MapCalloutView mCallout;
private MapView mMapView;
private MapController mMapController;
private List<CheckinGroupItemizedOverlay> mCheckinGroupOverlays;
private MyLocationOverlay mMyLocationOverlay;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.search_map_activity);
if (getLastNonConfigurationInstance() != null) {
mStateHolder = (StateHolder) getLastNonConfigurationInstance();
} else {
if (getIntent().hasExtra(EXTRA_CHECKIN_PARCELS)) {
Parcelable[] parcelables = getIntent().getParcelableArrayExtra(EXTRA_CHECKIN_PARCELS);
Group<Checkin> checkins = new Group<Checkin>();
for (int i = 0; i < parcelables.length; i++) {
checkins.add((Checkin)parcelables[i]);
}
mStateHolder = new StateHolder();
mStateHolder.setCheckins(checkins);
} else {
Log.e(TAG, "FriendsMapActivity requires checkin array in intent extras.");
finish();
return;
}
}
initMap();
}
@Override
public void onResume() {
super.onResume();
mMyLocationOverlay.enableMyLocation();
if (UiUtil.sdkVersion() > 3) {
mMyLocationOverlay.enableCompass();
}
}
@Override
public void onPause() {
super.onPause();
mMyLocationOverlay.disableMyLocation();
mMyLocationOverlay.disableCompass();
}
private void initMap() {
mMapView = (MapView) findViewById(R.id.mapView);
mMapView.setBuiltInZoomControls(true);
mMapController = mMapView.getController();
mMyLocationOverlay = new CrashFixMyLocationOverlay(this, mMapView);
mMapView.getOverlays().add(mMyLocationOverlay);
loadSearchResults(mStateHolder.getCheckins());
mCallout = (MapCalloutView) findViewById(R.id.map_callout);
mCallout.setVisibility(View.GONE);
mCallout.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(FriendsMapActivity.this, VenueActivity.class);
intent.setAction(Intent.ACTION_VIEW);
intent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_PARTIAL, mTappedVenue);
startActivity(intent);
}
});
recenterMap();
}
private void loadSearchResults(Group<Checkin> checkins) {
// One CheckinItemizedOverlay per group!
CheckinGroupItemizedOverlay mappableCheckinsOverlay = createMappableCheckinsOverlay(checkins);
mCheckinGroupOverlays = new ArrayList<CheckinGroupItemizedOverlay>();
if (mappableCheckinsOverlay != null) {
mCheckinGroupOverlays.add(mappableCheckinsOverlay);
}
// Only add the list of checkin group overlays if it contains any overlays.
if (mCheckinGroupOverlays.size() > 0) {
mMapView.getOverlays().addAll(mCheckinGroupOverlays);
} else {
Toast.makeText(this, getResources().getString(
R.string.friendsmapactivity_no_checkins), Toast.LENGTH_LONG).show();
}
}
/**
* Create an overlay that contains a specific group's list of mappable
* checkins.
*/
private CheckinGroupItemizedOverlay createMappableCheckinsOverlay(Group<Checkin> group) {
// We want to group checkins by venue. Do max three checkins per venue, a total
// of 100 venues total. We should only also display checkins that are within a
// city radius, and are at most three hours old.
CheckinTimestampSort timestamps = new CheckinTimestampSort();
Map<String, CheckinGroup> checkinMap = new HashMap<String, CheckinGroup>();
for (int i = 0, m = group.size(); i < m; i++) {
Checkin checkin = (Checkin)group.get(i);
Venue venue = checkin.getVenue();
if (VenueUtils.hasValidLocation(venue)) {
// Make sure the venue is within city radius.
try {
int distance = Integer.parseInt(checkin.getDistance());
if (distance > FriendsActivity.CITY_RADIUS_IN_METERS) {
continue;
}
} catch (NumberFormatException ex) {
// Distance was invalid, ignore this checkin.
continue;
}
// Make sure the checkin happened within the last three hours.
try {
Date date = new Date(checkin.getCreated());
if (date.before(timestamps.getBoundaryRecent())) {
continue;
}
} catch (Exception ex) {
// Timestamps was invalid, ignore this checkin.
continue;
}
String venueId = venue.getId();
CheckinGroup cg = checkinMap.get(venueId);
if (cg == null) {
cg = new CheckinGroup();
checkinMap.put(venueId, cg);
}
// Stop appending if we already have three checkins here.
if (cg.getCheckinCount() < 3) {
cg.appendCheckin(checkin);
}
}
// We can't have too many pins on the map.
if (checkinMap.size() > 99) {
break;
}
}
Group<CheckinGroup> mappableCheckins = new Group<CheckinGroup>(checkinMap.values());
if (mappableCheckins.size() > 0) {
CheckinGroupItemizedOverlay mappableCheckinsGroupOverlay = new CheckinGroupItemizedOverlay(
this,
((Foursquared) getApplication()).getRemoteResourceManager(),
this.getResources().getDrawable(R.drawable.pin_checkin_multiple),
mCheckinGroupOverlayTapListener);
mappableCheckinsGroupOverlay.setGroup(mappableCheckins);
return mappableCheckinsGroupOverlay;
} else {
return null;
}
}
private void recenterMap() {
// Previously we'd try to zoom to span, but this gives us odd results a lot of times,
// so falling back to zoom at a fixed level.
GeoPoint center = mMyLocationOverlay.getMyLocation();
if (center != null) {
Log.i(TAG, "Using my location overlay as center point for map centering.");
mMapController.animateTo(center);
mMapController.setZoom(16);
} else {
// Location overlay wasn't ready yet, try using last known geolocation from manager.
Location bestLocation = GeoUtils.getBestLastGeolocation(this);
if (bestLocation != null) {
Log.i(TAG, "Using last known location for map centering.");
mMapController.animateTo(GeoUtils.locationToGeoPoint(bestLocation));
mMapController.setZoom(16);
} else {
// We have no location information at all, so we'll just show the map at a high
// zoom level and the user can zoom in as they wish.
Log.i(TAG, "No location available for map centering.");
mMapController.setZoom(8);
}
}
}
/** Handle taps on one of the pins. */
private CheckinGroupOverlayTapListener mCheckinGroupOverlayTapListener =
new CheckinGroupOverlayTapListener() {
@Override
public void onTap(OverlayItem itemSelected, OverlayItem itemLastSelected, CheckinGroup cg) {
mTappedVenue = cg.getVenue();
mCallout.setTitle(cg.getVenue().getName());
mCallout.setMessage(cg.getDescription());
mCallout.setVisibility(View.VISIBLE);
mMapController.animateTo(new GeoPoint(cg.getLatE6(), cg.getLonE6()));
}
@Override
public void onTap(GeoPoint p, MapView mapView) {
mCallout.setVisibility(View.GONE);
}
};
@Override
protected boolean isRouteDisplayed() {
return false;
}
private static class StateHolder {
private Group<Checkin> mCheckins;
public StateHolder() {
mCheckins = new Group<Checkin>();
}
public Group<Checkin> getCheckins() {
return mCheckins;
}
public void setCheckins(Group<Checkin> checkins) {
mCheckins = checkins;
}
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquared.preferences.Preferences;
import com.joelapenna.foursquared.util.TabsUtil;
import com.joelapenna.foursquared.util.UiUtil;
import com.joelapenna.foursquared.util.UserUtils;
import android.app.Activity;
import android.app.TabActivity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.Window;
import android.widget.FrameLayout;
import android.widget.TabHost;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class MainActivity extends TabActivity {
public static final String TAG = "MainActivity";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
private TabHost mTabHost;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (DEBUG) Log.d(TAG, "onCreate()");
setDefaultKeyMode(Activity.DEFAULT_KEYS_SEARCH_LOCAL);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
// Don't start the main activity if we don't have credentials
if (!((Foursquared) getApplication()).isReady()) {
if (DEBUG) Log.d(TAG, "Not ready for user.");
redirectToLoginActivity();
}
if (DEBUG) Log.d(TAG, "Setting up main activity layout.");
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.main_activity);
initTabHost();
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
private void initTabHost() {
if (mTabHost != null) {
throw new IllegalStateException("Trying to intialize already initializd TabHost");
}
mTabHost = getTabHost();
// We may want to show the friends tab first, or the places tab first, depending on
// the user preferences.
SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(this);
// We can add more tabs here eventually, but if "Friends" isn't the startup tab, then
// we are left with "Places" being the startup tab instead.
String[] startupTabValues = getResources().getStringArray(R.array.startup_tabs_values);
String startupTab = settings.getString(
Preferences.PREFERENCE_STARTUP_TAB, startupTabValues[0]);
Intent intent = new Intent(this, NearbyVenuesActivity.class);
if (startupTab.equals(startupTabValues[0])) {
TabsUtil.addTab(mTabHost, getString(R.string.tab_main_nav_friends), R.drawable.tab_main_nav_friends_selector,
1, new Intent(this, FriendsActivity.class));
TabsUtil.addTab(mTabHost, getString(R.string.tab_main_nav_nearby), R.drawable.tab_main_nav_nearby_selector,
2, intent);
} else {
intent.putExtra(NearbyVenuesActivity.INTENT_EXTRA_STARTUP_GEOLOC_DELAY, 4000L);
TabsUtil.addTab(mTabHost, getString(R.string.tab_main_nav_nearby), R.drawable.tab_main_nav_nearby_selector,
1, intent);
TabsUtil.addTab(mTabHost, getString(R.string.tab_main_nav_friends), R.drawable.tab_main_nav_friends_selector,
2, new Intent(this, FriendsActivity.class));
}
TabsUtil.addTab(mTabHost, getString(R.string.tab_main_nav_tips), R.drawable.tab_main_nav_tips_selector,
3, new Intent(this, TipsActivity.class));
TabsUtil.addTab(mTabHost, getString(R.string.tab_main_nav_todos), R.drawable.tab_main_nav_todos_selector,
4, new Intent(this, TodosActivity.class));
// 'Me' tab, just shows our own info. At this point we should have a
// stored user id, and a user gender to control the image which is
// displayed on the tab.
String userId = ((Foursquared) getApplication()).getUserId();
String userGender = ((Foursquared) getApplication()).getUserGender();
Intent intentTabMe = new Intent(this, UserDetailsActivity.class);
intentTabMe.putExtra(UserDetailsActivity.EXTRA_USER_ID, userId == null ? "unknown"
: userId);
TabsUtil.addTab(mTabHost, getString(R.string.tab_main_nav_me),
UserUtils.getDrawableForMeTabByGender(userGender), 5, intentTabMe);
// Fix layout for 1.5.
if (UiUtil.sdkVersion() < 4) {
FrameLayout flTabContent = (FrameLayout)findViewById(android.R.id.tabcontent);
flTabContent.setPadding(0, 0, 0, 0);
}
}
private void redirectToLoginActivity() {
setVisible(false);
Intent intent = new Intent(this, LoginActivity.class);
intent.setAction(Intent.ACTION_MAIN);
intent.setFlags(
Intent.FLAG_ACTIVITY_NO_HISTORY |
Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS |
Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
finish();
}
}
| Java |
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.joelapenna.foursquared.preferences;
import android.content.Context;
import android.content.res.TypedArray;
import android.os.Parcelable;
import android.preference.Preference;
import android.util.AttributeSet;
import android.view.View;
/**
* This is an example of a custom preference type. The preference counts the number of clicks it has
* received and stores/retrieves it from the storage.
*/
public class ClickPreference extends Preference {
// This is the constructor called by the inflater
public ClickPreference(Context context, AttributeSet attrs) {
super(context, attrs);
}
@Override
protected void onBindView(View view) {
super.onBindView(view);
}
@Override
protected void onClick() {
// Data has changed, notify so UI can be refreshed!
notifyChanged();
}
@Override
protected Object onGetDefaultValue(TypedArray a, int index) {
// This preference type's value type is Integer, so we read the default
// value from the attributes as an Integer.
return a.getInteger(index, 0);
}
@Override
protected void onSetInitialValue(boolean restoreValue, Object defaultValue) {
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
super.onRestoreInstanceState(state);
notifyChanged();
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared.preferences;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareCredentialsException;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquare.types.City;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.FoursquaredSettings;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.StringFormatters;
import com.joelapenna.foursquared.util.UserUtils;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.res.Resources;
import android.util.Log;
import java.io.IOException;
import java.util.UUID;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class Preferences {
private static final String TAG = "Preferences";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
// Visible Preferences (sync with preferences.xml)
public static final String PREFERENCE_SHARE_CHECKIN = "share_checkin";
public static final String PREFERENCE_IMMEDIATE_CHECKIN = "immediate_checkin";
public static final String PREFERENCE_STARTUP_TAB = "startup_tab";
// Hacks for preference activity extra UI elements.
public static final String PREFERENCE_ADVANCED_SETTINGS = "advanced_settings";
public static final String PREFERENCE_TWITTER_CHECKIN = "twitter_checkin";
public static final String PREFERENCE_FACEBOOK_CHECKIN = "facebook_checkin";
public static final String PREFERENCE_TWITTER_HANDLE = "twitter_handle";
public static final String PREFERENCE_FACEBOOK_HANDLE = "facebook_handle";
public static final String PREFERENCE_FRIEND_REQUESTS = "friend_requests";
public static final String PREFERENCE_FRIEND_ADD = "friend_add";
public static final String PREFERENCE_CHANGELOG = "changelog";
public static final String PREFERENCE_CITY_NAME = "city_name";
public static final String PREFERENCE_LOGOUT = "logout";
public static final String PREFERENCE_HELP = "help";
public static final String PREFERENCE_SEND_FEEDBACK = "send_feedback";
public static final String PREFERENCE_PINGS = "pings_on";
public static final String PREFERENCE_PINGS_INTERVAL = "pings_refresh_interval_in_minutes";
public static final String PREFERENCE_PINGS_VIBRATE = "pings_vibrate";
public static final String PREFERENCE_TOS_PRIVACY = "tos_privacy";
public static final String PREFERENCE_PROFILE_SETTINGS = "profile_settings";
// Credentials related preferences
public static final String PREFERENCE_LOGIN = "phone";
public static final String PREFERENCE_PASSWORD = "password";
// Extra info for getUserCity
private static final String PREFERENCE_CITY_ID = "city_id";
private static final String PREFERENCE_CITY_GEOLAT = "city_geolat";
private static final String PREFERENCE_CITY_GEOLONG = "city_geolong";
private static final String PREFERENCE_CITY_SHORTNAME = "city_shortname";
// Extra info for getUserId
private static final String PREFERENCE_ID = "id";
// Extra for storing user's supplied email address.
private static final String PREFERENCE_USER_EMAIL = "user_email";
// Extra for storing user's supplied first and last name.
private static final String PREFERENCE_USER_NAME = "user_name";
// Extra info about the user, their gender, to control icon used for 'me' in the UI.
private static final String PREFERENCE_GENDER = "gender";
// Extra info, can the user have followers or not.
public static final String PREFERENCE_CAN_HAVE_FOLLOWERS = "can_have_followers";
// Not-in-XML preferences for dumpcatcher
public static final String PREFERENCE_DUMPCATCHER_CLIENT = "dumpcatcher_client";
// Keeps track of the last changelog version shown to the user at startup.
private static final String PREFERENCE_LAST_SEEN_CHANGELOG_VERSION
= "last_seen_changelog_version";
// User can choose to clear geolocation on each search.
public static final String PREFERENCE_CACHE_GEOLOCATION_FOR_SEARCHES
= "cache_geolocation_for_searches";
// If we're compiled to show the prelaunch activity, flag stating whether to skip
// showing it on startup.
public static final String PREFERENCE_SHOW_PRELAUNCH_ACTIVITY = "show_prelaunch_activity";
// Last time pings service ran.
public static final String PREFERENCE_PINGS_SERVICE_LAST_RUN_TIME = "pings_service_last_run_time";
// Broadcast an intent to show single full-screen images, or use our own poor image viewer.
public static final String PREFERENCE_NATIVE_IMAGE_VIEWER
= "native_full_size_image_viewer";
/**
* Gives us a chance to set some default preferences if this is the first install
* of the application.
*/
public static void setupDefaults(SharedPreferences preferences, Resources resources) {
Editor editor = preferences.edit();
if (!preferences.contains(PREFERENCE_STARTUP_TAB)) {
String[] startupTabValues = resources.getStringArray(R.array.startup_tabs_values);
editor.putString(PREFERENCE_STARTUP_TAB, startupTabValues[0]);
}
if (!preferences.contains(PREFERENCE_CACHE_GEOLOCATION_FOR_SEARCHES)) {
editor.putBoolean(PREFERENCE_CACHE_GEOLOCATION_FOR_SEARCHES, false);
}
if (!preferences.contains(PREFERENCE_SHOW_PRELAUNCH_ACTIVITY)) {
editor.putBoolean(PREFERENCE_SHOW_PRELAUNCH_ACTIVITY, true);
}
if (!preferences.contains(PREFERENCE_PINGS_INTERVAL)) {
editor.putString(PREFERENCE_PINGS_INTERVAL, "30");
}
if (!preferences.contains(PREFERENCE_NATIVE_IMAGE_VIEWER)) {
editor.putBoolean(PREFERENCE_NATIVE_IMAGE_VIEWER, true);
}
editor.commit();
}
public static String createUniqueId(SharedPreferences preferences) {
String uniqueId = preferences.getString(PREFERENCE_DUMPCATCHER_CLIENT, null);
if (uniqueId == null) {
uniqueId = UUID.randomUUID().toString();
Editor editor = preferences.edit();
editor.putString(PREFERENCE_DUMPCATCHER_CLIENT, uniqueId);
editor.commit();
}
return uniqueId;
}
public static boolean loginUser(Foursquare foursquare, String login, String password,
Foursquare.Location location, Editor editor) throws FoursquareCredentialsException,
FoursquareException, IOException {
if (DEBUG) Log.d(Preferences.TAG, "Trying to log in.");
foursquare.setCredentials(login, password);
storeLoginAndPassword(editor, login, password);
if (!editor.commit()) {
if (DEBUG) Log.d(TAG, "storeLoginAndPassword commit failed");
return false;
}
User user = foursquare.user(null, false, false, false, location);
storeUser(editor, user);
if (!editor.commit()) {
if (DEBUG) Log.d(TAG, "storeUser commit failed");
return false;
}
return true;
}
public static boolean logoutUser(Foursquare foursquare, Editor editor) {
if (DEBUG) Log.d(Preferences.TAG, "Trying to log out.");
// TODO: If we re-implement oAuth, we'll have to call clearAllCrendentials here.
foursquare.setCredentials(null, null);
return editor.clear().commit();
}
public static City getUserCity(SharedPreferences prefs) {
City city = new City();
city.setId(prefs.getString(Preferences.PREFERENCE_CITY_ID, null));
city.setName(prefs.getString(Preferences.PREFERENCE_CITY_NAME, null));
city.setShortname(prefs.getString(Preferences.PREFERENCE_CITY_SHORTNAME, null));
city.setGeolat(prefs.getString(Preferences.PREFERENCE_CITY_GEOLAT, null));
city.setGeolong(prefs.getString(Preferences.PREFERENCE_CITY_GEOLONG, null));
return city;
}
public static String getUserId(SharedPreferences prefs) {
return prefs.getString(PREFERENCE_ID, null);
}
public static String getUserName(SharedPreferences prefs) {
return prefs.getString(PREFERENCE_USER_NAME, null);
}
public static String getUserEmail(SharedPreferences prefs) {
return prefs.getString(PREFERENCE_USER_EMAIL, null);
}
public static String getUserGender(SharedPreferences prefs) {
return prefs.getString(PREFERENCE_GENDER, null);
}
public static String getLastSeenChangelogVersion(SharedPreferences prefs) {
return prefs.getString(PREFERENCE_LAST_SEEN_CHANGELOG_VERSION, null);
}
public static void storeCity(final Editor editor, City city) {
if (city != null) {
editor.putString(PREFERENCE_CITY_ID, city.getId());
editor.putString(PREFERENCE_CITY_GEOLAT, city.getGeolat());
editor.putString(PREFERENCE_CITY_GEOLONG, city.getGeolong());
editor.putString(PREFERENCE_CITY_NAME, city.getName());
editor.putString(PREFERENCE_CITY_SHORTNAME, city.getShortname());
}
}
public static void storeLoginAndPassword(final Editor editor, String login, String password) {
editor.putString(PREFERENCE_LOGIN, login);
editor.putString(PREFERENCE_PASSWORD, password);
}
public static void storeUser(final Editor editor, User user) {
if (user != null && user.getId() != null) {
editor.putString(PREFERENCE_ID, user.getId());
editor.putString(PREFERENCE_USER_NAME, StringFormatters.getUserFullName(user));
editor.putString(PREFERENCE_USER_EMAIL, user.getEmail());
editor.putBoolean(PREFERENCE_TWITTER_CHECKIN, user.getSettings().sendtotwitter());
editor.putBoolean(PREFERENCE_FACEBOOK_CHECKIN, user.getSettings().sendtofacebook());
editor.putString(PREFERENCE_TWITTER_HANDLE, user.getTwitter() != null ? user.getTwitter() : "");
editor.putString(PREFERENCE_FACEBOOK_HANDLE, user.getFacebook() != null ? user.getFacebook() : "");
editor.putString(PREFERENCE_GENDER, user.getGender());
editor.putBoolean(PREFERENCE_CAN_HAVE_FOLLOWERS, UserUtils.getCanHaveFollowers(user));
if (DEBUG) Log.d(TAG, "Setting user info");
} else {
if (Preferences.DEBUG) Log.d(Preferences.TAG, "Unable to lookup user.");
}
}
public static void storeLastSeenChangelogVersion(final Editor editor, String version) {
editor.putString(PREFERENCE_LAST_SEEN_CHANGELOG_VERSION, version);
if (!editor.commit()) {
Log.e(TAG, "storeLastSeenChangelogVersion commit failed");
}
}
public static boolean getUseNativeImageViewerForFullScreenImages(SharedPreferences prefs) {
return prefs.getBoolean(PREFERENCE_NATIVE_IMAGE_VIEWER, true);
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquared.util.NotificationsUtil;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.DialogInterface.OnCancelListener;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.widget.Toast;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
/**
* Handles fetching an image from the web, then writes it to a temporary file on
* the sdcard so we can hand it off to a view intent. This activity can be
* styled with a custom transparent-background theme, so that it appears like a
* simple progress dialog to the user over whichever activity launches it,
* instead of two seaparate activities before they finally get to the
* image-viewing activity. The only required intent extra is the URL to download
* the image, the others are optional:
* <ul>
* <li>IMAGE_URL - String, url of the image to download, either jpeg or png.</li>
* <li>CONNECTION_TIMEOUT_IN_SECONDS - int, optional, max timeout wait for
* download, in seconds.</li>
* <li>READ_TIMEOUT_IN_SECONDS - int, optional, max timeout wait for read of
* image, in seconds.</li>
* <li>PROGRESS_BAR_TITLE - String, optional, title of the progress bar during
* download.</li>
* <li>PROGRESS_BAR_MESSAGE - String, optional, message body of the progress bar
* during download.</li>
* </ul>
*
* When the download is complete, the activity will return the path of the
* saved image on disk. The calling activity can then choose to launch an
* intent to view the image.
*
* @date February 25, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public class FetchImageForViewIntent extends Activity {
private static final String TAG = "FetchImageForViewIntent";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private static final String TEMP_FILE_NAME = "tmp_fsq";
public static final String IMAGE_URL = Foursquared.PACKAGE_NAME
+ ".FetchImageForViewIntent.IMAGE_URL";
public static final String CONNECTION_TIMEOUT_IN_SECONDS = Foursquared.PACKAGE_NAME
+ ".FetchImageForViewIntent.CONNECTION_TIMEOUT_IN_SECONDS";
public static final String READ_TIMEOUT_IN_SECONDS = Foursquared.PACKAGE_NAME
+ ".FetchImageForViewIntent.READ_TIMEOUT_IN_SECONDS";
public static final String PROGRESS_BAR_TITLE = Foursquared.PACKAGE_NAME
+ ".FetchImageForViewIntent.PROGRESS_BAR_TITLE";
public static final String PROGRESS_BAR_MESSAGE = Foursquared.PACKAGE_NAME
+ ".FetchImageForViewIntent.PROGRESS_BAR_MESSAGE";
public static final String LAUNCH_VIEW_INTENT_ON_COMPLETION = Foursquared.PACKAGE_NAME
+ ".FetchImageForViewIntent.LAUNCH_VIEW_INTENT_ON_COMPLETION";
public static final String EXTRA_SAVED_IMAGE_PATH_RETURNED = Foursquared.PACKAGE_NAME
+ ".FetchImageForViewIntent.EXTRA_SAVED_IMAGE_PATH_RETURNED";
private StateHolder mStateHolder;
private ProgressDialog mDlgProgress;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (DEBUG) Log.d(TAG, "onCreate()");
setContentView(R.layout.fetch_image_for_view_intent_activity);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivity(this);
} else {
String url = null;
if (getIntent().getExtras().containsKey(IMAGE_URL)) {
url = getIntent().getExtras().getString(IMAGE_URL);
} else {
Log.e(TAG, "FetchImageForViewIntent requires intent extras parameter 'IMAGE_URL'.");
finish();
return;
}
if (DEBUG) Log.d(TAG, "Fetching image: " + url);
// Grab the extension of the file that should be present at the end
// of the url. We can do a better job of this, and could even check
// that the extension is of an expected type.
int posdot = url.lastIndexOf(".");
if (posdot < 0) {
Log.e(TAG, "FetchImageForViewIntent requires a url to an image resource with a file extension in its name.");
finish();
return;
}
String progressBarTitle = getIntent().getStringExtra(PROGRESS_BAR_TITLE);
String progressBarMessage = getIntent().getStringExtra(PROGRESS_BAR_MESSAGE);
if (progressBarMessage == null) {
progressBarMessage = "Fetching image...";
}
mStateHolder = new StateHolder();
mStateHolder.setLaunchViewIntentOnCompletion(
getIntent().getBooleanExtra(LAUNCH_VIEW_INTENT_ON_COMPLETION, true));
mStateHolder.startTask(
FetchImageForViewIntent.this,
url,
url.substring(posdot),
progressBarTitle,
progressBarMessage,
getIntent().getIntExtra(CONNECTION_TIMEOUT_IN_SECONDS, 20),
getIntent().getIntExtra(READ_TIMEOUT_IN_SECONDS, 20));
}
}
@Override
public void onResume() {
super.onResume();
if (mStateHolder.getIsRunning()) {
startProgressBar(mStateHolder.getProgressTitle(), mStateHolder.getProgressMessage());
}
}
@Override
public void onPause() {
super.onPause();
stopProgressBar();
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivity(null);
return mStateHolder;
}
private void startProgressBar(String title, String message) {
if (mDlgProgress == null) {
mDlgProgress = ProgressDialog.show(this, title, message);
mDlgProgress.setOnCancelListener(new OnCancelListener() {
@Override
public void onCancel(DialogInterface dlg) {
mStateHolder.cancel();
finish();
}
});
mDlgProgress.setCancelable(true);
}
mDlgProgress.setTitle(title);
mDlgProgress.setMessage(message);
}
private void stopProgressBar() {
if (mDlgProgress != null && mDlgProgress.isShowing()) {
mDlgProgress.dismiss();
}
mDlgProgress = null;
}
private void onFetchImageTaskComplete(Boolean result, String path, String extension,
Exception ex) {
try {
// If successful, start an intent to view the image.
if (result != null && result.equals(Boolean.TRUE)) {
// If the image can't be loaded or an intent can't be found to
// view it, launchViewIntent() will create a toast with an error
// message.
if (mStateHolder.getLaunchViewIntentOnCompletion()) {
launchViewIntent(path, extension);
} else {
// We'll finish now by handing the save image path back to the
// calling activity.
Intent intent = new Intent();
intent.putExtra(EXTRA_SAVED_IMAGE_PATH_RETURNED, path);
setResult(Activity.RESULT_OK, intent);
}
} else {
NotificationsUtil.ToastReasonForFailure(FetchImageForViewIntent.this, ex);
}
} finally {
// Whether download worked or not, we finish ourselves now. If an
// error occurred, the toast should remain on the calling activity.
mStateHolder.setIsRunning(false);
stopProgressBar();
finish();
}
}
private boolean launchViewIntent(String outputPath, String extension) {
Foursquared foursquared = (Foursquared) getApplication();
if (foursquared.getUseNativeImageViewerForFullScreenImages()) {
// Try to open the file now to create the uri we'll hand to the intent.
Uri uri = null;
try {
File file = new File(outputPath);
uri = Uri.fromFile(file);
} catch (Exception ex) {
Log.e(TAG, "Error opening downloaded image from temp location: ", ex);
Toast.makeText(this, "No application could be found to diplay the full image.",
Toast.LENGTH_SHORT);
return false;
}
// Try to start an intent to view the image. It's possible that the user
// may not have any intents to handle the request.
try {
Intent intent = new Intent(android.content.Intent.ACTION_VIEW);
intent.setDataAndType(uri, "image/" + extension);
startActivity(intent);
} catch (Exception ex) {
Log.e(TAG, "Error starting intent to view image: ", ex);
Toast.makeText(this, "There was an error displaying the image.", Toast.LENGTH_SHORT);
return false;
}
} else {
Intent intent = new Intent(this, FullSizeImageActivity.class);
intent.putExtra(FullSizeImageActivity.INTENT_EXTRA_IMAGE_PATH, outputPath);
startActivity(intent);
}
return true;
}
/**
* Handles fetching the image from the net and saving it to disk in a task.
*/
private static class FetchImageTask extends AsyncTask<Void, Void, Boolean> {
private FetchImageForViewIntent mActivity;
private final String mUrl;
private String mExtension;
private final String mOutputPath;
private final int mConnectionTimeoutInSeconds;
private final int mReadTimeoutInSeconds;
private Exception mReason;
public FetchImageTask(FetchImageForViewIntent activity, String url, String extension,
int connectionTimeoutInSeconds, int readTimeoutInSeconds) {
mActivity = activity;
mUrl = url;
mExtension = extension;
mOutputPath = Environment.getExternalStorageDirectory() + "/" + TEMP_FILE_NAME;
mConnectionTimeoutInSeconds = connectionTimeoutInSeconds;
mReadTimeoutInSeconds = readTimeoutInSeconds;
}
public void setActivity(FetchImageForViewIntent activity) {
mActivity = activity;
}
@Override
protected Boolean doInBackground(Void... params) {
try {
saveImage(mUrl, mOutputPath, mConnectionTimeoutInSeconds, mReadTimeoutInSeconds);
return Boolean.TRUE;
} catch (Exception e) {
if (DEBUG) Log.d(TAG, "FetchImageTask: Exception while fetching image.", e);
mReason = e;
}
return Boolean.FALSE;
}
@Override
protected void onPostExecute(Boolean result) {
if (DEBUG) Log.d(TAG, "FetchImageTask: onPostExecute()");
if (mActivity != null) {
mActivity.onFetchImageTaskComplete(result, mOutputPath, mExtension, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onFetchImageTaskComplete(null, null, null,
new FoursquareException("Image download cancelled."));
}
}
}
public static void saveImage(String urlImage, String savePath, int connectionTimeoutInSeconds,
int readTimeoutInSeconds) throws Exception {
URL url = new URL(urlImage);
URLConnection conn = url.openConnection();
conn.setConnectTimeout(connectionTimeoutInSeconds * 1000);
conn.setReadTimeout(readTimeoutInSeconds * 1000);
int contentLength = conn.getContentLength();
InputStream raw = conn.getInputStream();
InputStream in = new BufferedInputStream(raw);
byte[] data = new byte[contentLength];
int bytesRead = 0;
int offset = 0;
while (offset < contentLength) {
bytesRead = in.read(data, offset, data.length - offset);
if (bytesRead == -1) {
break;
}
offset += bytesRead;
}
in.close();
if (offset != contentLength) {
Log.e(TAG, "Error fetching image, only read " + offset + " bytes of " + contentLength
+ " total.");
throw new FoursquareException("Error fetching full image, please try again.");
}
// This will fail if the user has no sdcard present, catch it specifically
// to alert user.
try {
FileOutputStream out = new FileOutputStream(savePath);
out.write(data);
out.flush();
out.close();
} catch (Exception ex) {
Log.e(TAG, "Error saving fetched image to disk.", ex);
throw new FoursquareException("Error opening fetched image, make sure an sdcard is present.");
}
}
/** Maintains state between rotations. */
private static class StateHolder {
FetchImageTask mTaskFetchImage;
boolean mIsRunning;
String mProgressTitle;
String mProgressMessage;
boolean mLaunchViewIntentOnCompletion;
public StateHolder() {
mIsRunning = false;
mLaunchViewIntentOnCompletion = true;
}
public void startTask(FetchImageForViewIntent activity, String url, String extension,
String progressBarTitle, String progressBarMessage, int connectionTimeoutInSeconds,
int readTimeoutInSeconds) {
mIsRunning = true;
mProgressTitle = progressBarTitle;
mProgressMessage = progressBarMessage;
mTaskFetchImage = new FetchImageTask(activity, url, extension,
connectionTimeoutInSeconds, readTimeoutInSeconds);
mTaskFetchImage.execute();
}
public void setActivity(FetchImageForViewIntent activity) {
if (mTaskFetchImage != null) {
mTaskFetchImage.setActivity(activity);
}
}
public void setIsRunning(boolean isRunning) {
mIsRunning = isRunning;
}
public boolean getIsRunning() {
return mIsRunning;
}
public String getProgressTitle() {
return mProgressTitle;
}
public String getProgressMessage() {
return mProgressMessage;
}
public void cancel() {
if (mTaskFetchImage != null) {
mTaskFetchImage.cancel(true);
mIsRunning = false;
}
}
public boolean getLaunchViewIntentOnCompletion() {
return mLaunchViewIntentOnCompletion;
}
public void setLaunchViewIntentOnCompletion(boolean launchViewIntentOnCompletion) {
mLaunchViewIntentOnCompletion = launchViewIntentOnCompletion;
}
}
}
| Java |
/**
* Copyright 2008 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquared.preferences.Preferences;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.DialogInterface.OnClickListener;
import android.net.Uri;
import android.os.Bundle;
import android.preference.Preference;
import android.preference.PreferenceManager;
import android.preference.PreferenceScreen;
import android.preference.Preference.OnPreferenceChangeListener;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;
/**
* @author Joe LaPenna (joe@joelapenna.com)
* @author Mark Wyszomierski (markww@gmail.com)
* -added notifications settings (May 21, 2010).
* -removed user update, moved to NotificationSettingsActivity (June 2, 2010)
*/
public class PreferenceActivity extends android.preference.PreferenceActivity {
private static final String TAG = "PreferenceActivity";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private static final int DIALOG_TOS_PRIVACY = 1;
private static final int DIALOG_PROFILE_SETTINGS = 2;
private static final String URL_TOS = "http://foursquare.com/legal/terms";
private static final String URL_PRIVACY = "http://foursquare.com/legal/privacy";
private SharedPreferences mPrefs;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
addPreferencesFromResource(R.xml.preferences);
mPrefs = PreferenceManager.getDefaultSharedPreferences(this);
Preference advanceSettingsPreference = getPreferenceScreen().findPreference(
Preferences.PREFERENCE_ADVANCED_SETTINGS);
advanceSettingsPreference.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
((Foursquared) getApplication()).requestUpdateUser();
return false;
}
});
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
if (DEBUG) Log.d(TAG, "onPreferenceTreeClick");
String key = preference.getKey();
if (Preferences.PREFERENCE_LOGOUT.equals(key)) {
mPrefs.edit().clear().commit();
// TODO: If we re-implement oAuth, we'll have to call
// clearAllCrendentials here.
((Foursquared) getApplication()).getFoursquare().setCredentials(null, null);
Intent intent = new Intent(this, LoginActivity.class);
intent.setAction(Intent.ACTION_MAIN);
intent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY
| Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS | Intent.FLAG_ACTIVITY_CLEAR_TOP);
sendBroadcast(new Intent(Foursquared.INTENT_ACTION_LOGGED_OUT));
} else if (Preferences.PREFERENCE_ADVANCED_SETTINGS.equals(key)) {
startActivity(new Intent( //
Intent.ACTION_VIEW, Uri.parse(Foursquare.FOURSQUARE_PREFERENCES)));
} else if (Preferences.PREFERENCE_HELP.equals(key)) {
Intent intent = new Intent(this, WebViewActivity.class);
intent.putExtra(WebViewActivity.INTENT_EXTRA_URL, "http://foursquare.com/help/android");
startActivity(intent);
} else if (Preferences.PREFERENCE_SEND_FEEDBACK.equals(key)) {
startActivity(new Intent(this, SendLogActivity.class));
} else if (Preferences.PREFERENCE_FRIEND_ADD.equals(key)) {
startActivity(new Intent(this, AddFriendsActivity.class));
} else if (Preferences.PREFERENCE_FRIEND_REQUESTS.equals(key)) {
startActivity(new Intent(this, FriendRequestsActivity.class));
} else if (Preferences.PREFERENCE_CHANGELOG.equals(key)) {
startActivity(new Intent(this, ChangelogActivity.class));
} else if (Preferences.PREFERENCE_PINGS.equals(key)) {
startActivity(new Intent(this, PingsSettingsActivity.class));
} else if (Preferences.PREFERENCE_TOS_PRIVACY.equals(key)) {
showDialog(DIALOG_TOS_PRIVACY);
} else if (Preferences.PREFERENCE_PROFILE_SETTINGS.equals(key)) {
showDialog(DIALOG_PROFILE_SETTINGS);
}
return true;
}
@Override
protected Dialog onCreateDialog(int id) {
switch (id) {
case DIALOG_TOS_PRIVACY:
ArrayAdapter<String> adapterTos = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1);
adapterTos.add(getResources().getString(R.string.preference_activity_tos));
adapterTos.add(getResources().getString(R.string.preference_activity_privacy));
AlertDialog dlgInfo = new AlertDialog.Builder(this)
.setTitle(getResources().getString(R.string.preference_activity_tos_privacy_dlg_title))
.setAdapter(adapterTos, new OnClickListener() {
@Override
public void onClick(DialogInterface dlg, int pos) {
Intent intent = new Intent(PreferenceActivity.this, WebViewActivity.class);
switch (pos) {
case 0:
intent.putExtra(WebViewActivity.INTENT_EXTRA_URL, URL_TOS);
break;
case 1:
intent.putExtra(WebViewActivity.INTENT_EXTRA_URL, URL_PRIVACY);
break;
default:
return;
}
startActivity(intent);
}
})
.create();
return dlgInfo;
case DIALOG_PROFILE_SETTINGS:
String userId = ((Foursquared) getApplication()).getUserId();
String userName = ((Foursquared) getApplication()).getUserName();
String userEmail = ((Foursquared) getApplication()).getUserEmail();
LayoutInflater inflater = (LayoutInflater) getSystemService(Activity.LAYOUT_INFLATER_SERVICE);
View layout = inflater.inflate(R.layout.settings_user_info,
(ViewGroup) findViewById(R.id.settings_user_info_layout_root));
TextView tvUserId = (TextView)layout.findViewById(R.id.settings_user_info_label_user_id);
TextView tvUserName = (TextView)layout.findViewById(R.id.settings_user_info_label_user_name);
TextView tvUserEmail = (TextView)layout.findViewById(R.id.settings_user_info_label_user_email);
tvUserId.setText(userId);
tvUserName.setText(userName);
tvUserEmail.setText(userEmail);
AlertDialog dlgProfileSettings = new AlertDialog.Builder(this)
.setTitle(getResources().getString(R.string.preference_activity_profile_settings_dlg_title))
.setView(layout)
.create();
return dlgProfileSettings;
}
return null;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.CheckinResult;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.util.NotificationsUtil;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.location.Location;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.Window;
import android.widget.Toast;
/**
* Can be called to execute a shout. Should be presented with the transparent
* dialog theme to appear only as a progress bar. When execution is complete, a
* toast will be shown with a success or error message.
*
* For the location paramters of the checkin method, this activity will grab the
* global last-known best location.
*
* The activity will setResult(RESULT_OK) if the shout worked, and will
* setResult(RESULT_CANCELED) if it did not work.
*
* @date March 10, 2010
* @author Mark Wyszomierski (markww@gmail.com).
*/
public class ShoutExecuteActivity extends Activity {
public static final String TAG = "ShoutExecuteActivity";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String INTENT_EXTRA_SHOUT = Foursquared.PACKAGE_NAME
+ ".ShoutExecuteActivity.INTENT_EXTRA_SHOUT";
public static final String INTENT_EXTRA_TELL_FRIENDS = Foursquared.PACKAGE_NAME
+ ".ShoutExecuteActivity.INTENT_EXTRA_TELL_FRIENDS";
public static final String INTENT_EXTRA_TELL_FOLLOWERS = Foursquared.PACKAGE_NAME
+ ".ShoutExecuteActivity.INTENT_EXTRA_TELL_FOLLOWERS";
public static final String INTENT_EXTRA_TELL_TWITTER = Foursquared.PACKAGE_NAME
+ ".ShoutExecuteActivity.INTENT_EXTRA_TELL_TWITTER";
public static final String INTENT_EXTRA_TELL_FACEBOOK = Foursquared.PACKAGE_NAME
+ ".ShoutExecuteActivity.INTENT_EXTRA_TELL_FACEBOOK";
private StateHolder mStateHolder;
private ProgressDialog mDlgProgress;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (DEBUG) Log.d(TAG, "onCreate()");
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.checkin_execute_activity);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
// We start the checkin immediately on creation.
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivity(this);
} else {
mStateHolder = new StateHolder();
Foursquared foursquared = (Foursquared) getApplication();
Location location = foursquared.getLastKnownLocation();
mStateHolder.startTask(
this,
location,
getIntent().getExtras().getString(INTENT_EXTRA_SHOUT),
getIntent().getExtras().getBoolean(INTENT_EXTRA_TELL_FRIENDS, false),
getIntent().getExtras().getBoolean(INTENT_EXTRA_TELL_FOLLOWERS, false),
getIntent().getExtras().getBoolean(INTENT_EXTRA_TELL_TWITTER, false),
getIntent().getExtras().getBoolean(INTENT_EXTRA_TELL_FACEBOOK, false)
);
}
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivity(null);
return mStateHolder;
}
@Override
public void onResume() {
super.onResume();
if (mStateHolder.getIsRunning()) {
startProgressBar(getResources().getString(R.string.shout_action_label),
getResources().getString(R.string.shout_execute_activity_progress_bar_message));
}
}
@Override
public void onPause() {
super.onPause();
stopProgressBar();
if (isFinishing()) {
mStateHolder.cancelTasks();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
private void startProgressBar(String title, String message) {
if (mDlgProgress == null) {
mDlgProgress = ProgressDialog.show(this, title, message);
}
mDlgProgress.show();
}
private void stopProgressBar() {
if (mDlgProgress != null) {
mDlgProgress.dismiss();
mDlgProgress = null;
}
}
private void onShoutComplete(CheckinResult result, Exception ex) {
mStateHolder.setIsRunning(false);
stopProgressBar();
if (result != null) {
Toast.makeText(this, getResources().getString(R.string.shout_exceute_activity_result),
Toast.LENGTH_LONG).show();
setResult(Activity.RESULT_OK);
} else {
NotificationsUtil.ToastReasonForFailure(this, ex);
setResult(Activity.RESULT_CANCELED);
}
finish();
}
private static class ShoutTask extends AsyncTask<Void, Void, CheckinResult> {
private ShoutExecuteActivity mActivity;
private Location mLocation;
private String mShout;
private boolean mTellFriends;
private boolean mTellFollowers;
private boolean mTellTwitter;
private boolean mTellFacebook;
private Exception mReason;
public ShoutTask(ShoutExecuteActivity activity,
Location location,
String shout,
boolean tellFriends,
boolean tellFollowers,
boolean tellTwitter,
boolean tellFacebook) {
mActivity = activity;
mLocation = location;
mShout = shout;
mTellFriends = tellFriends;
mTellFollowers = tellFollowers;
mTellTwitter = tellTwitter;
mTellFacebook = tellFacebook;
}
public void setActivity(ShoutExecuteActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
mActivity.startProgressBar(mActivity.getResources().getString(
R.string.shout_action_label), mActivity.getResources().getString(
R.string.shout_execute_activity_progress_bar_message));
}
@Override
protected CheckinResult doInBackground(Void... params) {
try {
Foursquared foursquared = (Foursquared) mActivity.getApplication();
Foursquare foursquare = foursquared.getFoursquare();
CheckinResult result =
foursquare.checkin(
null,
null,
LocationUtils.createFoursquareLocation(mLocation),
mShout,
!mTellFriends, // (isPrivate)
mTellFollowers,
mTellTwitter,
mTellFacebook);
return result;
} catch (Exception e) {
if (DEBUG) Log.d(TAG, "ShoutTask: Exception checking in.", e);
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(CheckinResult result) {
if (DEBUG) Log.d(TAG, "ShoutTask: onPostExecute()");
if (mActivity != null) {
mActivity.onShoutComplete(result, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onShoutComplete(null, new Exception(
"Shout cancelled."));
}
}
}
private static class StateHolder {
private ShoutTask mTask;
private boolean mIsRunning;
public StateHolder() {
mIsRunning = false;
}
public void startTask(ShoutExecuteActivity activity,
Location location,
String shout,
boolean tellFriends,
boolean tellFollowers,
boolean tellTwitter,
boolean tellFacebook) {
mIsRunning = true;
mTask = new ShoutTask(activity, location, shout, tellFriends, tellFollowers,
tellTwitter, tellFacebook);
mTask.execute();
}
public void setActivity(ShoutExecuteActivity activity) {
if (mTask != null) {
mTask.setActivity(activity);
}
}
public boolean getIsRunning() {
return mIsRunning;
}
public void setIsRunning(boolean isRunning) {
mIsRunning = isRunning;
}
public void cancelTasks() {
if (mTask != null && mIsRunning) {
mTask.setActivity(null);
mTask.cancel(true);
}
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.app.LoadableListActivity;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.util.NotificationsUtil;
import com.joelapenna.foursquared.widget.FriendListAdapter;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
/**
* Shows a list of friends for the user id passed as an intent extra.
*
* @date March 9, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class UserDetailsFriendsActivity extends LoadableListActivity {
static final String TAG = "UserDetailsFriendsActivity";
static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String EXTRA_USER_ID = Foursquared.PACKAGE_NAME
+ ".UserDetailsFriendsActivity.EXTRA_USER_ID";
public static final String EXTRA_USER_NAME = Foursquared.PACKAGE_NAME
+ ".UserDetailsFriendsActivity.EXTRA_USER_NAME";
public static final String EXTRA_SHOW_ADD_FRIEND_OPTIONS = Foursquared.PACKAGE_NAME
+ ".UserDetailsFriendsActivity.EXTRA_SHOW_ADD_FRIEND_OPTIONS";
private StateHolder mStateHolder;
private FriendListAdapter mListAdapter;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivityForTaskFriends(this);
} else {
if (getIntent().hasExtra(EXTRA_USER_ID) && getIntent().hasExtra(EXTRA_USER_NAME)) {
mStateHolder = new StateHolder(
getIntent().getStringExtra(EXTRA_USER_ID),
getIntent().getStringExtra(EXTRA_USER_NAME));
} else {
Log.e(TAG, TAG + " requires a userid and username in its intent extras.");
finish();
return;
}
mStateHolder.startTaskFriends(this);
}
ensureUi();
}
@Override
public void onPause() {
super.onPause();
if (isFinishing()) {
mStateHolder.cancelTasks();
mListAdapter.removeObserver();
}
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivityForTaskFriends(null);
return mStateHolder;
}
private void ensureUi() {
mListAdapter = new FriendListAdapter(this,
((Foursquared) getApplication()).getRemoteResourceManager());
mListAdapter.setGroup(mStateHolder.getFriends());
ListView listView = getListView();
listView.setAdapter(mListAdapter);
listView.setSmoothScrollbarEnabled(true);
listView.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
User user = (User) parent.getAdapter().getItem(position);
Intent intent = new Intent(UserDetailsFriendsActivity.this, UserDetailsActivity.class);
intent.putExtra(UserDetailsActivity.EXTRA_USER_PARCEL, user);
intent.putExtra(UserDetailsActivity.EXTRA_SHOW_ADD_FRIEND_OPTIONS, true);
startActivity(intent);
}
});
if (mStateHolder.getIsRunningFriendsTask()) {
setLoadingView();
} else if (mStateHolder.getFetchedFriendsOnce() && mStateHolder.getFriends().size() == 0) {
setEmptyView();
}
setTitle(getString(R.string.user_details_friends_activity_title, mStateHolder.getUsername()));
}
private void onFriendsTaskComplete(Group<User> group, Exception ex) {
mListAdapter.removeObserver();
mListAdapter = new FriendListAdapter(this,
((Foursquared) getApplication()).getRemoteResourceManager());
if (group != null) {
mStateHolder.setFriends(group);
mListAdapter.setGroup(mStateHolder.getFriends());
getListView().setAdapter(mListAdapter);
}
else {
mStateHolder.setFriends(new Group<User>());
mListAdapter.setGroup(mStateHolder.getFriends());
getListView().setAdapter(mListAdapter);
NotificationsUtil.ToastReasonForFailure(this, ex);
}
mStateHolder.setIsRunningFriendsTask(false);
mStateHolder.setFetchedFriendsOnce(true);
// TODO: We can probably tighten this up by just calling ensureUI() again.
if (mStateHolder.getFriends().size() == 0) {
setEmptyView();
}
}
/**
* Gets friends of the current user we're working for.
*/
private static class FriendsTask extends AsyncTask<String, Void, Group<User>> {
private UserDetailsFriendsActivity mActivity;
private Exception mReason;
public FriendsTask(UserDetailsFriendsActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
mActivity.setLoadingView();
}
@Override
protected Group<User> doInBackground(String... params) {
try {
Foursquared foursquared = (Foursquared) mActivity.getApplication();
Foursquare foursquare = foursquared.getFoursquare();
return foursquare.friends(
params[0], LocationUtils.createFoursquareLocation(foursquared.getLastKnownLocation()));
} catch (Exception e) {
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(Group<User> users) {
if (mActivity != null) {
mActivity.onFriendsTaskComplete(users, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onFriendsTaskComplete(null, mReason);
}
}
public void setActivity(UserDetailsFriendsActivity activity) {
mActivity = activity;
}
}
private static class StateHolder {
private String mUserId;
private String mUsername;
private Group<User> mFriends;
private FriendsTask mTaskFriends;
private boolean mIsRunningFriendsTask;
private boolean mFetchedFriendsOnce;
public StateHolder(String userId, String username) {
mUserId = userId;
mUsername = username;
mIsRunningFriendsTask = false;
mFetchedFriendsOnce = false;
mFriends = new Group<User>();
}
public String getUsername() {
return mUsername;
}
public Group<User> getFriends() {
return mFriends;
}
public void setFriends(Group<User> friends) {
mFriends = friends;
}
public void startTaskFriends(UserDetailsFriendsActivity activity) {
mIsRunningFriendsTask = true;
mTaskFriends = new FriendsTask(activity);
mTaskFriends.execute(mUserId);
}
public void setActivityForTaskFriends(UserDetailsFriendsActivity activity) {
if (mTaskFriends != null) {
mTaskFriends.setActivity(activity);
}
}
public void setIsRunningFriendsTask(boolean isRunning) {
mIsRunningFriendsTask = isRunning;
}
public boolean getIsRunningFriendsTask() {
return mIsRunningFriendsTask;
}
public void setFetchedFriendsOnce(boolean fetchedOnce) {
mFetchedFriendsOnce = fetchedOnce;
}
public boolean getFetchedFriendsOnce() {
return mFetchedFriendsOnce;
}
public void cancelTasks() {
if (mTaskFriends != null) {
mTaskFriends.setActivity(null);
mTaskFriends.cancel(true);
}
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import android.app.Dialog;
import android.content.Context;
import android.os.Bundle;
import android.view.Display;
import android.view.WindowManager;
import android.webkit.WebView;
import android.widget.LinearLayout;
/**
* Renders the result of a checkin using a CheckinResult object. This is called
* from CheckinExecuteActivity. It would be nicer to put this in another activity,
* but right now the CheckinResult is quite large and would require a good amount
* of work to add serializers for all its inner classes. This wouldn't be a huge
* problem, but maintaining it as the classes evolve could more trouble than it's
* worth.
*
* The only way the user can dismiss this dialog is by hitting the 'back' key.
* CheckingExecuteActivity depends on this so it knows when to finish() itself.
*
* @date March 3, 2010.
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*
*/
public class WebViewDialog extends Dialog
{
private WebView mWebView;
private String mTitle;
private String mContent;
public WebViewDialog(Context context, String title, String content) {
super(context, R.style.ThemeCustomDlgBase_ThemeCustomDlg);
mTitle = title;
mContent = content;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.webview_dialog);
setTitle(mTitle);
mWebView = (WebView)findViewById(R.id.webView);
mWebView.loadDataWithBaseURL("--", mContent, "text/html", "utf-8", "");
LinearLayout llMain = (LinearLayout)findViewById(R.id.llMain);
inflateDialog(llMain);
}
/**
* Force-inflates a dialog main linear-layout to take max available screen space even though
* contents might not occupy full screen size.
*/
public static void inflateDialog(LinearLayout layout) {
WindowManager wm = (WindowManager) layout.getContext().getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();
layout.setMinimumWidth(display.getWidth() - 30);
layout.setMinimumHeight(display.getHeight() - 40);
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.util.VenueUtils;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeMap;
/**
* Queries the system for any apps that can be used for sharing data,
* like sms or email. Package exploration is largely taken from Mark
* Murphy's commonsware projects:
*
* http://github.com/commonsguy/cw-advandroid
*
* @date September 22, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class VenueShareActivity extends Activity {
public static final String TAG = "VenueShareActivity";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String INTENT_EXTRA_VENUE = Foursquared.PACKAGE_NAME
+ ".VenueShareActivity.INTENT_EXTRA_VENUE";
private StateHolder mStateHolder;
private ShareAdapter mListAdapter;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
setContentView(R.layout.venue_share_activity);
setTitle(getString(R.string.venue_share_activity_title));
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
} else {
mStateHolder = new StateHolder();
if (getIntent().hasExtra(INTENT_EXTRA_VENUE)) {
mStateHolder.setVenue((Venue)getIntent().getExtras().getParcelable(INTENT_EXTRA_VENUE));
} else {
Log.e(TAG, "VenueShareActivity requires a venue parcel its intent extras.");
finish();
return;
}
}
ensureUi();
}
@Override
public void onPause() {
super.onPause();
if (isFinishing()) {
unregisterReceiver(mLoggedOutReceiver);
}
}
@Override
public Object onRetainNonConfigurationInstance() {
return mStateHolder;
}
private void ensureUi() {
mListAdapter = new ShareAdapter(this, getPackageManager(), findAppsForSharing());
ListView listView = (ListView)findViewById(R.id.listview);
listView.setAdapter(mListAdapter);
listView.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
launchAppIntent(position);
}
});
}
private void launchAppIntent(int position) {
ResolveInfo launchable = mListAdapter.getItem(position);
ActivityInfo activity = launchable.activityInfo;
ComponentName componentName = new ComponentName(
activity.applicationInfo.packageName, activity.name);
Intent intent = new Intent(Intent.ACTION_SEND);
intent.addCategory(Intent.CATEGORY_DEFAULT);
intent.setComponent(componentName);
intent.setType("text/plain");
intent.putExtra(android.content.Intent.EXTRA_SUBJECT,
"Foursquare Venue Share");
intent.putExtra(android.content.Intent.EXTRA_TEXT,
VenueUtils.toStringVenueShare(mStateHolder.getVenue()));
startActivity(intent);
finish();
}
private List<ResolveInfo> findAppsForSharing() {
Intent intent = new Intent(Intent.ACTION_SEND, null);
intent.addCategory(Intent.CATEGORY_DEFAULT);
intent.setType("text/plain");
List<ResolveInfo> activities = getPackageManager().queryIntentActivities(intent, 0);
TreeMap<String, ResolveInfo> alpha = new TreeMap<String, ResolveInfo>();
for (ResolveInfo it : activities) {
alpha.put(it.loadLabel(getPackageManager()).toString(), it);
}
return new ArrayList<ResolveInfo>(alpha.values());
}
private class ShareAdapter extends ArrayAdapter<ResolveInfo> {
public ShareAdapter(Context context, PackageManager pm, List<ResolveInfo> apps) {
super(context, R.layout.user_actions_list_item, apps);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (convertView == null) {
convertView = newView(parent);
}
bindView(position, convertView);
return(convertView);
}
private View newView(ViewGroup parent) {
return (getLayoutInflater().inflate(R.layout.user_actions_list_item, parent, false));
}
private void bindView(int position, View view) {
PackageManager packageManager = getPackageManager();
ImageView icon = (ImageView)view.findViewById(R.id.userActionsListItemIcon);
icon.setImageDrawable(getItem(position).loadIcon(packageManager));
TextView label = (TextView)view.findViewById(R.id.userActionsListItemLabel);
label.setText(getItem(position).loadLabel(packageManager));
}
}
private static class StateHolder {
private Venue mVenue;
public StateHolder() {
}
public Venue getVenue() {
return mVenue;
}
public void setVenue(Venue venue) {
mVenue = venue;
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.util.NotificationsUtil;
import com.joelapenna.foursquared.widget.FriendRequestsAdapter;
import android.app.ListActivity;
import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.text.Editable;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* Presents the user with a list of pending friend requests that they can
* approve or deny.
*
* @date February 12, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public class FriendRequestsActivity extends ListActivity {
private static final String TAG = "FriendRequestsActivity";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private static final int MENU_REFRESH = 0;
private StateHolder mStateHolder;
private ProgressDialog mDlgProgress;
private EditText mEditTextFilter;
private FriendRequestsAdapter mListAdapter;
private TextView mTextViewNoRequests;
private Handler mHandler;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (DEBUG) Log.d(TAG, "onCreate()");
setContentView(R.layout.friend_requests_activity);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
mHandler = new Handler();
mEditTextFilter = (EditText)findViewById(R.id.editTextFilter);
mEditTextFilter.addTextChangedListener(new TextWatcher() {
public void afterTextChanged(Editable s) {
}
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
public void onTextChanged(CharSequence s, int start, int before, int count) {
// Run the filter operation after a brief waiting period in case the user
// is typing real fast.
mHandler.removeCallbacks(mRunnableFilter);
mHandler.postDelayed(mRunnableFilter, 700L);
}
});
mListAdapter = new FriendRequestsAdapter(this, mButtonRowClickHandler,
((Foursquared) getApplication()).getRemoteResourceManager());
getListView().setAdapter(mListAdapter);
getListView().setItemsCanFocus(true);
mTextViewNoRequests = (TextView)findViewById(R.id.textViewNoRequests);
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivityForTaskFriendRequests(this);
mStateHolder.setActivityForTaskSendDecision(this);
decideShowNoFriendRequestsTextView();
} else {
mStateHolder = new StateHolder();
// Start searching for friend requests immediately on activity creation.
startProgressBar(getResources().getString(R.string.friend_requests_activity_label),
getResources().getString(R.string.friend_requests_progress_bar_find_requests));
mStateHolder.startTaskFriendRequests(FriendRequestsActivity.this);
}
}
@Override
public void onResume() {
super.onResume();
if (mStateHolder.getIsRunningFriendRequest()) {
startProgressBar(getResources().getString(R.string.friend_requests_activity_label),
getResources().getString(R.string.friend_requests_progress_bar_find_requests));
} else if (mStateHolder.getIsRunningApproval()) {
startProgressBar(getResources().getString(R.string.friend_requests_activity_label),
getResources()
.getString(R.string.friend_requests_progress_bar_approve_request));
} else if (mStateHolder.getIsRunningIgnore()) {
startProgressBar(getResources().getString(R.string.friend_requests_activity_label),
getResources()
.getString(R.string.friend_requests_progress_bar_ignore_request));
}
mListAdapter.setGroup(mStateHolder.getFoundFriendsFiltered());
mListAdapter.notifyDataSetChanged();
}
@Override
public void onPause() {
super.onPause();
stopProgressBar();
if (isFinishing()) {
mListAdapter.removeObserver();
}
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivityForTaskFriendRequests(null);
mStateHolder.setActivityForTaskSendDecision(null);
return mStateHolder;
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
menu.add(Menu.NONE, MENU_REFRESH, Menu.NONE, R.string.refresh).setIcon(
R.drawable.ic_menu_refresh);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_REFRESH:
startProgressBar(getResources().getString(R.string.friend_requests_activity_label),
getResources().getString(R.string.friend_requests_progress_bar_find_requests));
mStateHolder.setRanFetchOnce(false);
mStateHolder.startTaskFriendRequests(FriendRequestsActivity.this);
decideShowNoFriendRequestsTextView();
return true;
}
return super.onOptionsItemSelected(item);
}
private void startProgressBar(String title, String message) {
if (mDlgProgress == null) {
mDlgProgress = ProgressDialog.show(this, title, message);
}
mDlgProgress.show();
}
private void stopProgressBar() {
if (mDlgProgress != null) {
mDlgProgress.dismiss();
mDlgProgress = null;
}
}
private void infoFriendRequest(User user) {
Intent intent = new Intent(this, UserDetailsActivity.class);
intent.putExtra(UserDetailsActivity.EXTRA_USER_PARCEL, user);
startActivity(intent);
}
private void approveFriendRequest(User user) {
startProgressBar(getResources().getString(R.string.friend_requests_activity_label),
getResources().getString(R.string.friend_requests_progress_bar_approve_request));
mStateHolder.startTaskSendDecision(FriendRequestsActivity.this, user.getId(), true);
}
private void denyFriendRequest(User user) {
startProgressBar(getResources().getString(R.string.friend_requests_activity_label),
getResources().getString(R.string.friend_requests_progress_bar_ignore_request));
mStateHolder.startTaskSendDecision(FriendRequestsActivity.this, user.getId(), false);
}
private void decideShowNoFriendRequestsTextView() {
if (mStateHolder.getRanFetchOnce() &&
mStateHolder.getFoundFriendsCount() < 1) {
mTextViewNoRequests.setVisibility(View.VISIBLE);
}
else {
mTextViewNoRequests.setVisibility(View.GONE);
}
}
private void onFriendRequestsTaskComplete(Group<User> users, HashMap<String, Group<User>> usersAlpha, Exception ex) {
// Recreate the adapter, cleanup beforehand.
mListAdapter.removeObserver();
mListAdapter = new FriendRequestsAdapter(this, mButtonRowClickHandler,
((Foursquared) getApplication()).getRemoteResourceManager());
try {
// Populate the list control below now.
if (users != null) {
mStateHolder.setFoundFriends(users, usersAlpha);
if (DEBUG) {
Log.e(TAG, "Alpha-sorted requests map:");
for (Map.Entry<String, Group<User>> it : usersAlpha.entrySet()) {
Log.e(TAG, it.getKey());
for (User jt : it.getValue()) {
Log.e(TAG, " " + getUsersDisplayName(jt));
}
}
}
} else {
// If error, feed list adapter empty user group.
mStateHolder.setFoundFriends(null, null);
NotificationsUtil.ToastReasonForFailure(FriendRequestsActivity.this, ex);
}
mListAdapter.setGroup(mStateHolder.getFoundFriendsFiltered());
} finally {
getListView().setAdapter(mListAdapter);
mStateHolder.setIsRunningFriendRequest(false);
mStateHolder.setRanFetchOnce(true);
decideShowNoFriendRequestsTextView();
stopProgressBar();
}
}
private void onFriendRequestDecisionTaskComplete(User user, boolean isApproving, Exception ex) {
try {
// If sending the request was successful, then we need to remove
// that user from the list adapter. We do a linear search to find the
// matching row.
if (user != null) {
mStateHolder.removeUser(user);
mListAdapter.setGroup(mStateHolder.getFoundFriendsFiltered());
mListAdapter.notifyDataSetChanged();
// This should generate the message: "You're now friends with [name]!" if
// the user chose to approve the request, otherwise we show no toast, just
// remove from the list.
if (isApproving) {
Toast.makeText(this,
getResources().getString(R.string.friend_requests_approved) + " " +
getUsersDisplayName(user) + "!",
Toast.LENGTH_SHORT).show();
}
} else {
NotificationsUtil.ToastReasonForFailure(this, ex);
}
} finally {
decideShowNoFriendRequestsTextView();
mStateHolder.setIsRunningApprval(false);
mStateHolder.setIsRunningIgnore(false);
stopProgressBar();
}
}
private static class GetFriendRequestsTask extends AsyncTask<Void, Void, Group<User>> {
private FriendRequestsActivity mActivity;
private Exception mReason;
private HashMap<String, Group<User>> mRequestsAlpha;
public GetFriendRequestsTask(FriendRequestsActivity activity) {
mActivity = activity;
mRequestsAlpha = new LinkedHashMap<String, Group<User>>();
}
public void setActivity(FriendRequestsActivity activity) {
mActivity = activity;
}
@Override
protected Group<User> doInBackground(Void... params) {
try {
Foursquared foursquared = (Foursquared) mActivity.getApplication();
Foursquare foursquare = foursquared.getFoursquare();
Group<User> requests = foursquare.friendRequests();
for (User it : requests) {
String name = getUsersDisplayName(it).toUpperCase();
String first = name.substring(0, 1);
Group<User> block = mRequestsAlpha.get(first);
if (block == null) {
block = new Group<User>();
mRequestsAlpha.put(first, block);
}
block.add(it);
}
return requests;
} catch (Exception e) {
if (DEBUG) Log.d(TAG, "FindFriendsTask: Exception doing add friends by name", e);
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(Group<User> users) {
if (DEBUG) Log.d(TAG, "FindFriendsTask: onPostExecute()");
if (mActivity != null) {
mActivity.onFriendRequestsTaskComplete(users, mRequestsAlpha, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onFriendRequestsTaskComplete(null, null, new Exception(
"Friend search cancelled."));
}
}
}
private static class SendFriendRequestDecisionTask extends AsyncTask<Void, Void, User> {
private FriendRequestsActivity mActivity;
private boolean mIsApproving;
private String mUserId;
private Exception mReason;
public SendFriendRequestDecisionTask(FriendRequestsActivity activity,
String userId,
boolean isApproving) {
mActivity = activity;
mUserId = userId;
mIsApproving = isApproving;
}
public void setActivity(FriendRequestsActivity activity) {
mActivity = activity;
}
@Override
protected User doInBackground(Void... params) {
try {
Foursquared foursquared = (Foursquared) mActivity.getApplication();
Foursquare foursquare = foursquared.getFoursquare();
User user = null;
if (mIsApproving) {
user = foursquare.friendApprove(mUserId);
} else {
user = foursquare.friendDeny(mUserId);
}
return user;
} catch (Exception e) {
if (DEBUG)
Log.d(TAG, "SendFriendRequestTask: Exception doing send friend request.", e);
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(User user) {
if (DEBUG) Log.d(TAG, "SendFriendRequestTask: onPostExecute()");
if (mActivity != null) {
mActivity.onFriendRequestDecisionTaskComplete(user, mIsApproving, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onFriendRequestDecisionTaskComplete(null, mIsApproving,
new Exception("Friend request cancelled."));
}
}
}
private static class StateHolder {
GetFriendRequestsTask mTaskFriendRequests;
SendFriendRequestDecisionTask mTaskSendDecision;
boolean mIsRunningFriendRequests;
boolean mIsRunningApproval;
boolean mIsRunningIgnore;
boolean mRanFetchOnce;
private Group<User> mFoundFriends;
private Group<User> mFoundFriendsFiltered;
private HashMap<String, Group<User>> mFoundFriendsAlpha;
public StateHolder() {
mFoundFriends = new Group<User>();
mFoundFriendsFiltered = null;
mFoundFriendsAlpha = null;
mIsRunningFriendRequests = false;
mIsRunningApproval = false;
mIsRunningIgnore = false;
mRanFetchOnce = false;
}
public void startTaskFriendRequests(FriendRequestsActivity activity) {
mIsRunningFriendRequests = true;
mTaskFriendRequests = new GetFriendRequestsTask(activity);
mTaskFriendRequests.execute();
}
public void startTaskSendDecision(FriendRequestsActivity activity, String userId,
boolean approve) {
mIsRunningApproval = approve;
mIsRunningIgnore = !approve;
mTaskSendDecision = new SendFriendRequestDecisionTask(activity, userId, approve);
mTaskSendDecision.execute();
}
public void setActivityForTaskFriendRequests(FriendRequestsActivity activity) {
if (mTaskFriendRequests != null) {
mTaskFriendRequests.setActivity(activity);
}
}
public void setActivityForTaskSendDecision(FriendRequestsActivity activity) {
if (mTaskSendDecision != null) {
mTaskSendDecision.setActivity(activity);
}
}
public void setIsRunningFriendRequest(boolean isRunning) {
mIsRunningFriendRequests = isRunning;
}
public boolean getIsRunningFriendRequest() {
return mIsRunningFriendRequests;
}
public boolean getIsRunningApproval() {
return mIsRunningApproval;
}
public void setIsRunningApprval(boolean isRunning) {
mIsRunningApproval = isRunning;
}
public boolean getIsRunningIgnore() {
return mIsRunningIgnore;
}
public void setIsRunningIgnore(boolean isRunning) {
mIsRunningIgnore = isRunning;
}
public boolean getRanFetchOnce() {
return mRanFetchOnce;
}
public void setRanFetchOnce(boolean ranFetchOnce) {
mRanFetchOnce = ranFetchOnce;
}
public int getFoundFriendsCount() {
return mFoundFriends.size();
}
public Group<User> getFoundFriendsFiltered() {
if (mFoundFriendsFiltered == null) {
return mFoundFriends;
}
return mFoundFriendsFiltered;
}
public void setFoundFriends(Group<User> requests, HashMap<String, Group<User>> alpha) {
if (requests != null) {
mFoundFriends = requests;
mFoundFriendsFiltered = null;
mFoundFriendsAlpha = alpha;
} else {
mFoundFriends = new Group<User>();
mFoundFriendsFiltered = null;
mFoundFriendsAlpha = null;
}
}
public void filterFriendRequests(String filterString) {
// If no filter, just keep using the original found friends group.
// If a filter is supplied, reconstruct the group using the alpha
// map so we don't have to go through the entire list.
mFoundFriendsFiltered = null;
if (!TextUtils.isEmpty(filterString)) {
filterString = filterString.toUpperCase();
Group<User> alpha = mFoundFriendsAlpha.get(filterString.substring(0, 1));
mFoundFriendsFiltered = new Group<User>();
if (alpha != null) {
for (User it : alpha) {
String name = getUsersDisplayName(it).toUpperCase();
if (name.startsWith(filterString)) {
mFoundFriendsFiltered.add(it);
}
}
}
}
}
public void removeUser(User user) {
for (User it : mFoundFriends) {
if (it.getId().equals(user.getId())) {
mFoundFriends.remove(it);
break;
}
}
if (mFoundFriendsFiltered != null) {
for (User it : mFoundFriendsFiltered) {
if (it.getId().equals(user.getId())) {
mFoundFriendsFiltered.remove(it);
break;
}
}
}
String name = getUsersDisplayName(user).toUpperCase();
String first = name.substring(0, 1);
Group<User> alpha = mFoundFriendsAlpha.get(first);
for (User it : alpha) {
if (it.getId().equals(user.getId())) {
alpha.remove(it);
break;
}
}
}
}
private static String getUsersDisplayName(User user) {
StringBuilder sb = new StringBuilder(64);
if (!TextUtils.isEmpty(user.getFirstname())) {
sb.append(user.getFirstname());
sb.append(" ");
}
if (!TextUtils.isEmpty(user.getLastname())) {
sb.append(user.getLastname());
}
return sb.toString();
}
private FriendRequestsAdapter.ButtonRowClickHandler mButtonRowClickHandler =
new FriendRequestsAdapter.ButtonRowClickHandler() {
@Override
public void onBtnClickIgnore(User user) {
denyFriendRequest(user);
}
@Override
public void onBtnClickAdd(User user) {
approveFriendRequest(user);
}
@Override
public void onInfoAreaClick(User user) {
infoFriendRequest(user);
}
};
private Runnable mRunnableFilter = new Runnable() {
public void run() {
mStateHolder.filterFriendRequests(mEditTextFilter.getText().toString());
mListAdapter.setGroup(mStateHolder.getFoundFriendsFiltered());
mListAdapter.notifyDataSetChanged();
}
};
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquare.types.Settings;
import com.joelapenna.foursquare.types.User;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
/**
* Lets the user set pings on/off for a given friend.
*
* @date September 25, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class UserDetailsPingsActivity extends Activity {
private static final String TAG = "UserDetailsPingsActivity";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String EXTRA_USER_PARCEL = Foursquared.PACKAGE_NAME
+ ".UserDetailsPingsActivity.EXTRA_USER_PARCEL";
public static final String EXTRA_USER_RETURNED = Foursquared.PACKAGE_NAME
+ ".UserDetailsPingsActivity.EXTRA_USER_RETURNED";
private StateHolder mStateHolder;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.user_details_pings_activity);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivity(this);
setPreparedResultIntent();
} else {
mStateHolder = new StateHolder();
if (getIntent().getExtras() != null) {
if (getIntent().hasExtra(EXTRA_USER_PARCEL)) {
User user = getIntent().getExtras().getParcelable(EXTRA_USER_PARCEL);
mStateHolder.setUser(user);
} else {
Log.e(TAG, TAG + " requires a user pareclable in its intent extras.");
finish();
return;
}
} else {
Log.e(TAG, "TipActivity requires a tip pareclable in its intent extras.");
finish();
return;
}
}
ensureUi();
}
@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivity(null);
return mStateHolder;
}
private void ensureUi() {
User user = mStateHolder.getUser();
TextView tv = (TextView)findViewById(R.id.userDetailsPingsActivityDescription);
Button btn = (Button)findViewById(R.id.userDetailsPingsActivityButton);
if (user.getSettings().getGetPings()) {
tv.setText(getString(R.string.user_details_pings_activity_description_on,
user.getFirstname()));
btn.setText(getString(R.string.user_details_pings_activity_pings_off,
user.getFirstname()));
btn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
v.setEnabled(false);
setProgressBarIndeterminateVisibility(true);
mStateHolder.startPingsTask(UserDetailsPingsActivity.this, false);
}
});
} else {
tv.setText(getString(R.string.user_details_pings_activity_description_off,
user.getFirstname()));
btn.setText(getString(R.string.user_details_pings_activity_pings_on,
user.getFirstname()));
btn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
v.setEnabled(false);
setProgressBarIndeterminateVisibility(true);
mStateHolder.startPingsTask(UserDetailsPingsActivity.this, true);
}
});
}
if (mStateHolder.getIsRunningTaskPings()) {
btn.setEnabled(false);
setProgressBarIndeterminateVisibility(true);
} else {
btn.setEnabled(true);
setProgressBarIndeterminateVisibility(false);
}
}
private void setPreparedResultIntent() {
if (mStateHolder.getPreparedResult() != null) {
setResult(Activity.RESULT_OK, mStateHolder.getPreparedResult());
}
}
private void prepareResultIntent() {
Intent intent = new Intent();
intent.putExtra(EXTRA_USER_RETURNED, mStateHolder.getUser());
mStateHolder.setPreparedResult(intent);
setPreparedResultIntent();
}
private void onTaskPingsComplete(Settings settings, String userId, boolean on, Exception ex) {
mStateHolder.setIsRunningTaskPings(false);
// The api is returning pings = false for all cases, so manually overwrite,
// assume a non-null settings object is success.
if (settings != null) {
settings.setGetPings(on);
mStateHolder.setSettingsResult(settings);
prepareResultIntent();
} else {
Toast.makeText(this, ex.toString(), Toast.LENGTH_LONG).show();
}
ensureUi();
}
private static class TaskPings extends AsyncTask<Void, Void, Settings> {
private UserDetailsPingsActivity mActivity;
private String mUserId;
private boolean mOn;
private Exception mReason;
public TaskPings(UserDetailsPingsActivity activity, String userId, boolean on) {
mActivity = activity;
mUserId = userId;
mOn = on;
}
public void setActivity(UserDetailsPingsActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
mActivity.ensureUi();
}
@Override
protected Settings doInBackground(Void... params) {
try {
Foursquared foursquared = (Foursquared) mActivity.getApplication();
Foursquare foursquare = foursquared.getFoursquare();
return foursquare.setpings(mUserId, mOn);
} catch (Exception e) {
if (DEBUG) Log.d(TAG, "TipTask: Exception performing tip task.", e);
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(Settings settings) {
if (mActivity != null) {
mActivity.onTaskPingsComplete(settings, mUserId, mOn, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onTaskPingsComplete(null, mUserId, mOn, new FoursquareException("Tip task cancelled."));
}
}
}
private static class StateHolder {
private User mUser;
private boolean mIsRunningTask;
private Intent mPreparedResult;
private TaskPings mTaskPings;
public StateHolder() {
mPreparedResult = null;
mIsRunningTask = false;
}
public User getUser() {
return mUser;
}
public void setUser(User user) {
mUser = user;
}
public void setSettingsResult(Settings settings) {
mUser.getSettings().setGetPings(settings.getGetPings());
}
public void startPingsTask(UserDetailsPingsActivity activity, boolean on) {
if (!mIsRunningTask) {
mIsRunningTask = true;
mTaskPings = new TaskPings(activity, mUser.getId(), on);
mTaskPings.execute();
}
}
public void setActivity(UserDetailsPingsActivity activity) {
if (mTaskPings != null) {
mTaskPings.setActivity(activity);
}
}
public void setIsRunningTaskPings(boolean isRunning) {
mIsRunningTask = isRunning;
}
public boolean getIsRunningTaskPings() {
return mIsRunningTask;
}
public Intent getPreparedResult() {
return mPreparedResult;
}
public void setPreparedResult(Intent intent) {
mPreparedResult = intent;
}
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareError;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquare.util.IconUtils;
import com.joelapenna.foursquared.app.FoursquaredService;
import com.joelapenna.foursquared.error.LocationException;
import com.joelapenna.foursquared.location.BestLocationListener;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.preferences.Preferences;
import com.joelapenna.foursquared.util.JavaLoggingHandler;
import com.joelapenna.foursquared.util.NullDiskCache;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import android.app.Application;
import android.appwidget.AppWidgetManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.location.Location;
import android.location.LocationManager;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.preference.PreferenceManager;
import android.text.TextUtils;
import android.util.Log;
import java.io.File;
import java.io.IOException;
import java.util.Observer;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class Foursquared extends Application {
private static final String TAG = "Foursquared";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
static {
Logger.getLogger("com.joelapenna.foursquare").addHandler(new JavaLoggingHandler());
Logger.getLogger("com.joelapenna.foursquare").setLevel(Level.ALL);
}
public static final String PACKAGE_NAME = "com.joelapenna.foursquared";
public static final String INTENT_ACTION_LOGGED_OUT = "com.joelapenna.foursquared.intent.action.LOGGED_OUT";
public static final String INTENT_ACTION_LOGGED_IN = "com.joelapenna.foursquared.intent.action.LOGGED_IN";
private String mVersion = null;
private TaskHandler mTaskHandler;
private HandlerThread mTaskThread;
private SharedPreferences mPrefs;
private RemoteResourceManager mRemoteResourceManager;
private Foursquare mFoursquare;
private BestLocationListener mBestLocationListener = new BestLocationListener();
private boolean mIsFirstRun;
@Override
public void onCreate() {
Log.i(TAG, "Using Debug Server:\t" + FoursquaredSettings.USE_DEBUG_SERVER);
Log.i(TAG, "Using Dumpcatcher:\t" + FoursquaredSettings.USE_DUMPCATCHER);
Log.i(TAG, "Using Debug Log:\t" + DEBUG);
mVersion = getVersionString(this);
// Check if this is a new install by seeing if our preference file exists on disk.
mIsFirstRun = checkIfIsFirstRun();
// Setup Prefs (to load dumpcatcher)
mPrefs = PreferenceManager.getDefaultSharedPreferences(this);
// Setup some defaults in our preferences if not set yet.
Preferences.setupDefaults(mPrefs, getResources());
// If we're on a high density device, request higher res images. This singleton
// is picked up by the parsers to replace their icon urls with high res versions.
float screenDensity = getApplicationContext().getResources().getDisplayMetrics().density;
IconUtils.get().setRequestHighDensityIcons(screenDensity > 1.0f);
// Setup Dumpcatcher - We've outgrown this infrastructure but we'll
// leave its calls in place for the day that someone pays for some
// appengine quota.
// if (FoursquaredSettings.USE_DUMPCATCHER) {
// Resources resources = getResources();
// new DumpcatcherHelper(Preferences.createUniqueId(mPrefs), resources);
// }
// Sometimes we want the application to do some work on behalf of the
// Activity. Lets do that
// asynchronously.
mTaskThread = new HandlerThread(TAG + "-AsyncThread");
mTaskThread.start();
mTaskHandler = new TaskHandler(mTaskThread.getLooper());
// Set up storage cache.
loadResourceManagers();
// Catch sdcard state changes
new MediaCardStateBroadcastReceiver().register();
// Catch logins or logouts.
new LoggedInOutBroadcastReceiver().register();
// Log into Foursquare, if we can.
loadFoursquare();
}
public boolean isReady() {
return getFoursquare().hasLoginAndPassword() && !TextUtils.isEmpty(getUserId());
}
public Foursquare getFoursquare() {
return mFoursquare;
}
public String getUserId() {
return Preferences.getUserId(mPrefs);
}
public String getUserName() {
return Preferences.getUserName(mPrefs);
}
public String getUserEmail() {
return Preferences.getUserEmail(mPrefs);
}
public String getUserGender() {
return Preferences.getUserGender(mPrefs);
}
public String getVersion() {
if (mVersion != null) {
return mVersion;
} else {
return "";
}
}
public String getLastSeenChangelogVersion() {
return Preferences.getLastSeenChangelogVersion(mPrefs);
}
public void storeLastSeenChangelogVersion(String version) {
Preferences.storeLastSeenChangelogVersion(mPrefs.edit(), version);
}
public boolean getUseNativeImageViewerForFullScreenImages() {
return Preferences.getUseNativeImageViewerForFullScreenImages(mPrefs);
}
public RemoteResourceManager getRemoteResourceManager() {
return mRemoteResourceManager;
}
public BestLocationListener requestLocationUpdates(boolean gps) {
mBestLocationListener.register(
(LocationManager) getSystemService(Context.LOCATION_SERVICE), gps);
return mBestLocationListener;
}
public BestLocationListener requestLocationUpdates(Observer observer) {
mBestLocationListener.addObserver(observer);
mBestLocationListener.register(
(LocationManager) getSystemService(Context.LOCATION_SERVICE), true);
return mBestLocationListener;
}
public void removeLocationUpdates() {
mBestLocationListener
.unregister((LocationManager) getSystemService(Context.LOCATION_SERVICE));
}
public void removeLocationUpdates(Observer observer) {
mBestLocationListener.deleteObserver(observer);
this.removeLocationUpdates();
}
public Location getLastKnownLocation() {
return mBestLocationListener.getLastKnownLocation();
}
public Location getLastKnownLocationOrThrow() throws LocationException {
Location location = mBestLocationListener.getLastKnownLocation();
if (location == null) {
throw new LocationException();
}
return location;
}
public void clearLastKnownLocation() {
mBestLocationListener.clearLastKnownLocation();
}
public void requestStartService() {
mTaskHandler.sendMessage( //
mTaskHandler.obtainMessage(TaskHandler.MESSAGE_START_SERVICE));
}
public void requestUpdateUser() {
mTaskHandler.sendEmptyMessage(TaskHandler.MESSAGE_UPDATE_USER);
}
private void loadFoursquare() {
// Try logging in and setting up foursquare oauth, then user
// credentials.
if (FoursquaredSettings.USE_DEBUG_SERVER) {
mFoursquare = new Foursquare(Foursquare.createHttpApi("10.0.2.2:8080", mVersion, false));
} else {
mFoursquare = new Foursquare(Foursquare.createHttpApi(mVersion, false));
}
if (FoursquaredSettings.DEBUG) Log.d(TAG, "loadCredentials()");
String phoneNumber = mPrefs.getString(Preferences.PREFERENCE_LOGIN, null);
String password = mPrefs.getString(Preferences.PREFERENCE_PASSWORD, null);
mFoursquare.setCredentials(phoneNumber, password);
if (mFoursquare.hasLoginAndPassword()) {
sendBroadcast(new Intent(INTENT_ACTION_LOGGED_IN));
} else {
sendBroadcast(new Intent(INTENT_ACTION_LOGGED_OUT));
}
}
/**
* Provides static access to a Foursquare instance. This instance is
* initiated without user credentials.
*
* @param context the context to use when constructing the Foursquare
* instance
* @return the Foursquare instace
*/
public static Foursquare createFoursquare(Context context) {
String version = getVersionString(context);
if (FoursquaredSettings.USE_DEBUG_SERVER) {
return new Foursquare(Foursquare.createHttpApi("10.0.2.2:8080", version, false));
} else {
return new Foursquare(Foursquare.createHttpApi(version, false));
}
}
/**
* Constructs the version string of the application.
*
* @param context the context to use for getting package info
* @return the versions string of the application
*/
private static String getVersionString(Context context) {
// Get a version string for the app.
try {
PackageManager pm = context.getPackageManager();
PackageInfo pi = pm.getPackageInfo(PACKAGE_NAME, 0);
return PACKAGE_NAME + ":" + String.valueOf(pi.versionCode);
} catch (NameNotFoundException e) {
if (DEBUG) Log.d(TAG, "Could not retrieve package info", e);
throw new RuntimeException(e);
}
}
private void loadResourceManagers() {
// We probably don't have SD card access if we get an
// IllegalStateException. If it did, lets
// at least have some sort of disk cache so that things don't npe when
// trying to access the
// resource managers.
try {
if (DEBUG) Log.d(TAG, "Attempting to load RemoteResourceManager(cache)");
mRemoteResourceManager = new RemoteResourceManager("cache");
} catch (IllegalStateException e) {
if (DEBUG) Log.d(TAG, "Falling back to NullDiskCache for RemoteResourceManager");
mRemoteResourceManager = new RemoteResourceManager(new NullDiskCache());
}
}
public boolean getIsFirstRun() {
return mIsFirstRun;
}
private boolean checkIfIsFirstRun() {
File file = new File(
"/data/data/com.joelapenna.foursquared/shared_prefs/com.joelapenna.foursquared_preferences.xml");
return !file.exists();
}
/**
* Set up resource managers on the application depending on SD card state.
*
* @author Joe LaPenna (joe@joelapenna.com)
*/
private class MediaCardStateBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG)
Log
.d(TAG, "Media state changed, reloading resource managers:"
+ intent.getAction());
if (Intent.ACTION_MEDIA_UNMOUNTED.equals(intent.getAction())) {
getRemoteResourceManager().shutdown();
loadResourceManagers();
} else if (Intent.ACTION_MEDIA_MOUNTED.equals(intent.getAction())) {
loadResourceManagers();
}
}
public void register() {
// Register our media card broadcast receiver so we can
// enable/disable the cache as
// appropriate.
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED);
intentFilter.addAction(Intent.ACTION_MEDIA_MOUNTED);
// intentFilter.addAction(Intent.ACTION_MEDIA_REMOVED);
// intentFilter.addAction(Intent.ACTION_MEDIA_SHARED);
// intentFilter.addAction(Intent.ACTION_MEDIA_BAD_REMOVAL);
// intentFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTABLE);
// intentFilter.addAction(Intent.ACTION_MEDIA_NOFS);
// intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_STARTED);
// intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_FINISHED);
intentFilter.addDataScheme("file");
registerReceiver(this, intentFilter);
}
}
private class LoggedInOutBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if (INTENT_ACTION_LOGGED_IN.equals(intent.getAction())) {
requestUpdateUser();
}
}
public void register() {
// Register our media card broadcast receiver so we can
// enable/disable the cache as
// appropriate.
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(INTENT_ACTION_LOGGED_IN);
intentFilter.addAction(INTENT_ACTION_LOGGED_OUT);
registerReceiver(this, intentFilter);
}
}
private class TaskHandler extends Handler {
private static final int MESSAGE_UPDATE_USER = 1;
private static final int MESSAGE_START_SERVICE = 2;
public TaskHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (DEBUG) Log.d(TAG, "handleMessage: " + msg.what);
switch (msg.what) {
case MESSAGE_UPDATE_USER:
try {
// Update user info
Log.d(TAG, "Updating user.");
// Use location when requesting user information, if we
// have it.
Foursquare.Location location = LocationUtils
.createFoursquareLocation(getLastKnownLocation());
User user = getFoursquare().user(
null, false, false, false, location);
Editor editor = mPrefs.edit();
Preferences.storeUser(editor, user);
editor.commit();
if (location == null) {
// Pump the location listener, we don't have a
// location in our listener yet.
Log.d(TAG, "Priming Location from user city.");
Location primeLocation = new Location("foursquare");
// Very inaccurate, right?
primeLocation.setTime(System.currentTimeMillis());
mBestLocationListener.updateLocation(primeLocation);
}
} catch (FoursquareError e) {
if (DEBUG) Log.d(TAG, "FoursquareError", e);
// TODO Auto-generated catch block
} catch (FoursquareException e) {
if (DEBUG) Log.d(TAG, "FoursquareException", e);
// TODO Auto-generated catch block
} catch (IOException e) {
if (DEBUG) Log.d(TAG, "IOException", e);
// TODO Auto-generated catch block
}
return;
case MESSAGE_START_SERVICE:
Intent serviceIntent = new Intent(Foursquared.this, FoursquaredService.class);
serviceIntent.setAction(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
startService(serviceIntent);
return;
}
}
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquared.error.LocationException;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.util.NotificationsUtil;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.util.Log;
import android.view.Window;
import android.webkit.WebChromeClient;
import android.webkit.WebView;
import android.webkit.WebViewClient;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class StatsActivity extends Activity {
public static final String TAG = "StatsActivity";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_PROGRESS);
setContentView(R.layout.stats_activity);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
setTitle(getResources().getString(R.string.stats_activity_scoreboard));
WebView webView = (WebView) findViewById(R.id.webView);
webView.setWebViewClient(new MyWebViewClient());
webView.setWebChromeClient(new MyWebChromeClient());
Foursquared foursquared = ((Foursquared) getApplication());
String userId = ((Foursquared) getApplication()).getUserId();
try {
String url = Foursquare.createLeaderboardUrl(userId, LocationUtils
.createFoursquareLocation(foursquared.getLastKnownLocationOrThrow()));
Log.d(TAG, url);
webView.loadUrl(url);
} catch (LocationException e) {
NotificationsUtil.ToastReasonForFailure(this, e);
finish();
}
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
private class MyWebChromeClient extends WebChromeClient {
@Override
public void onProgressChanged(WebView view, int newProgress) {
setProgress(newProgress * 100);
}
}
private class MyWebViewClient extends WebViewClient {
@Override
public void onPageFinished(WebView view, String url) {
setProgressBarVisibility(false);
}
@Override
public void onPageStarted(WebView view, String url, Bitmap favicon) {
setProgressBarVisibility(true);
}
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return true;
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Tip;
import com.joelapenna.foursquare.types.Todo;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.app.LoadableListActivity;
import com.joelapenna.foursquared.util.VenueUtils;
import com.joelapenna.foursquared.widget.TodosListAdapter;
/**
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class VenueTodosActivity extends LoadableListActivity {
public static final String TAG = "VenueTodosActivity";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String INTENT_EXTRA_VENUE = Foursquared.PACKAGE_NAME
+ ".VenueTodosActivity.INTENT_EXTRA_VENUE";
public static final String INTENT_EXTRA_RETURN_VENUE = Foursquared.PACKAGE_NAME
+ ".VenueTodosActivity.INTENT_EXTRA_RETURN_VENUE";
private static final int ACTIVITY_TIP = 500;
private TodosListAdapter mListAdapter;
private StateHolder mStateHolder;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
setPreparedResultIntent();
} else {
mStateHolder = new StateHolder();
if (getIntent().hasExtra(INTENT_EXTRA_VENUE)) {
mStateHolder.setVenue((Venue)getIntent().getExtras().getParcelable(INTENT_EXTRA_VENUE));
} else {
Log.e(TAG, "VenueTodosActivity requires a venue parcel its intent extras.");
finish();
return;
}
}
ensureUi();
}
@Override
public void onPause() {
super.onPause();
if (isFinishing()) {
mListAdapter.removeObserver();
unregisterReceiver(mLoggedOutReceiver);
}
}
@Override
public Object onRetainNonConfigurationInstance() {
return mStateHolder;
}
private void ensureUi() {
Group<Todo> todos = mStateHolder.getVenue().getTodos();
mListAdapter = new TodosListAdapter(this, ((Foursquared) getApplication()).getRemoteResourceManager());
mListAdapter.setGroup(todos);
mListAdapter.setDisplayTodoVenueTitles(false);
ListView listView = getListView();
listView.setAdapter(mListAdapter);
listView.setSmoothScrollbarEnabled(true);
listView.setDividerHeight(0);
listView.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
// The tip that was clicked won't have its venue member set, since we got
// here by viewing the parent venue. In this case, we request that the tip
// activity not let the user recursively start drilling down past here.
// Create a dummy venue which has only the name and address filled in.
Venue venue = new Venue();
venue.setName(mStateHolder.getVenue().getName());
venue.setAddress(mStateHolder.getVenue().getAddress());
venue.setCrossstreet(mStateHolder.getVenue().getCrossstreet());
Todo todo = (Todo) parent.getAdapter().getItem(position);
if (todo.getTip() != null) {
todo.getTip().setVenue(venue);
Intent intent = new Intent(VenueTodosActivity.this, TipActivity.class);
intent.putExtra(TipActivity.EXTRA_TIP_PARCEL, todo.getTip());
intent.putExtra(TipActivity.EXTRA_VENUE_CLICKABLE, false);
startActivityForResult(intent, ACTIVITY_TIP);
}
}
});
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == ACTIVITY_TIP && resultCode == Activity.RESULT_OK) {
Tip tip = (Tip)data.getParcelableExtra(TipActivity.EXTRA_TIP_RETURNED);
Todo todo = data.hasExtra(TipActivity.EXTRA_TODO_RETURNED) ?
(Todo)data.getParcelableExtra(TipActivity.EXTRA_TODO_RETURNED) : null;
updateTip(tip, todo);
}
}
private void updateTip(Tip tip, Todo todo) {
// Changes to a tip status can produce or remove a to-do from
// the venue, update it now.
VenueUtils.handleTipChange(mStateHolder.getVenue(), tip, todo);
// If there are no more todos, there's nothing left to.. do.
prepareResultIntent();
if (mStateHolder.getVenue().getHasTodo()) {
mListAdapter.notifyDataSetInvalidated();
} else {
finish();
}
}
private void prepareResultIntent() {
Intent intent = new Intent();
intent.putExtra(INTENT_EXTRA_RETURN_VENUE, mStateHolder.getVenue());
mStateHolder.setPreparedResult(intent);
setPreparedResultIntent();
}
private void setPreparedResultIntent() {
if (mStateHolder.getPreparedResult() != null) {
setResult(Activity.RESULT_OK, mStateHolder.getPreparedResult());
}
}
private static class StateHolder {
private Venue mVenue;
private Intent mPreparedResult;
public StateHolder() {
mPreparedResult = null;
}
public Venue getVenue() {
return mVenue;
}
public void setVenue(Venue venue) {
mVenue = venue;
}
public Intent getPreparedResult() {
return mPreparedResult;
}
public void setPreparedResult(Intent intent) {
mPreparedResult = intent;
}
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.preferences.Preferences;
import com.joelapenna.foursquared.util.NotificationsUtil;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.text.Editable;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class LoginActivity extends Activity {
public static final String TAG = "LoginActivity";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
private AsyncTask<Void, Void, Boolean> mLoginTask;
private TextView mNewAccountTextView;
private EditText mPhoneUsernameEditText;
private EditText mPasswordEditText;
private ProgressDialog mProgressDialog;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (DEBUG) Log.d(TAG, "onCreate()");
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.login_activity);
Preferences.logoutUser( //
((Foursquared) getApplication()).getFoursquare(), //
PreferenceManager.getDefaultSharedPreferences(this).edit());
// Set up the UI.
ensureUi();
// Re-task if the request was cancelled.
mLoginTask = (LoginTask) getLastNonConfigurationInstance();
if (mLoginTask != null && mLoginTask.isCancelled()) {
if (DEBUG) Log.d(TAG, "LoginTask previously cancelled, trying again.");
mLoginTask = new LoginTask().execute();
}
}
@Override
public void onResume() {
super.onResume();
((Foursquared) getApplication()).requestLocationUpdates(false);
}
@Override
public void onPause() {
super.onPause();
((Foursquared) getApplication()).removeLocationUpdates();
}
@Override
public Object onRetainNonConfigurationInstance() {
if (DEBUG) Log.d(TAG, "onRetainNonConfigurationInstance()");
if (mLoginTask != null) {
mLoginTask.cancel(true);
}
return mLoginTask;
}
private ProgressDialog showProgressDialog() {
if (mProgressDialog == null) {
ProgressDialog dialog = new ProgressDialog(this);
dialog.setTitle(R.string.login_dialog_title);
dialog.setMessage(getString(R.string.login_dialog_message));
dialog.setIndeterminate(true);
dialog.setCancelable(true);
mProgressDialog = dialog;
}
mProgressDialog.show();
return mProgressDialog;
}
private void dismissProgressDialog() {
try {
mProgressDialog.dismiss();
} catch (IllegalArgumentException e) {
// We don't mind. android cleared it for us.
}
}
private void ensureUi() {
final Button button = (Button) findViewById(R.id.button);
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
mLoginTask = new LoginTask().execute();
}
});
mNewAccountTextView = (TextView) findViewById(R.id.newAccountTextView);
mNewAccountTextView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(
Intent.ACTION_VIEW, Uri.parse(Foursquare.FOURSQUARE_MOBILE_SIGNUP)));
}
});
mPhoneUsernameEditText = ((EditText) findViewById(R.id.phoneEditText));
mPasswordEditText = ((EditText) findViewById(R.id.passwordEditText));
TextWatcher fieldValidatorTextWatcher = new TextWatcher() {
@Override
public void afterTextChanged(Editable s) {
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
button.setEnabled(phoneNumberEditTextFieldIsValid()
&& passwordEditTextFieldIsValid());
}
private boolean phoneNumberEditTextFieldIsValid() {
// This can be either a phone number or username so we don't
// care too much about the
// format.
return !TextUtils.isEmpty(mPhoneUsernameEditText.getText());
}
private boolean passwordEditTextFieldIsValid() {
return !TextUtils.isEmpty(mPasswordEditText.getText());
}
};
mPhoneUsernameEditText.addTextChangedListener(fieldValidatorTextWatcher);
mPasswordEditText.addTextChangedListener(fieldValidatorTextWatcher);
}
private class LoginTask extends AsyncTask<Void, Void, Boolean> {
private static final String TAG = "LoginTask";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private Exception mReason;
@Override
protected void onPreExecute() {
if (DEBUG) Log.d(TAG, "onPreExecute()");
showProgressDialog();
}
@Override
protected Boolean doInBackground(Void... params) {
if (DEBUG) Log.d(TAG, "doInBackground()");
SharedPreferences prefs = PreferenceManager
.getDefaultSharedPreferences(LoginActivity.this);
Editor editor = prefs.edit();
Foursquared foursquared = (Foursquared) getApplication();
Foursquare foursquare = foursquared.getFoursquare();
try {
String phoneNumber = mPhoneUsernameEditText.getText().toString();
String password = mPasswordEditText.getText().toString();
Foursquare.Location location = null;
location = LocationUtils.createFoursquareLocation(
foursquared.getLastKnownLocation());
boolean loggedIn = Preferences.loginUser(foursquare, phoneNumber, password,
location, editor);
// Make sure prefs makes a round trip.
String userId = Preferences.getUserId(prefs);
if (TextUtils.isEmpty(userId)) {
if (DEBUG) Log.d(TAG, "Preference store calls failed");
throw new FoursquareException(getResources().getString(
R.string.login_failed_login_toast));
}
return loggedIn;
} catch (Exception e) {
if (DEBUG) Log.d(TAG, "Caught Exception logging in.", e);
mReason = e;
Preferences.logoutUser(foursquare, editor);
return false;
}
}
@Override
protected void onPostExecute(Boolean loggedIn) {
if (DEBUG) Log.d(TAG, "onPostExecute(): " + loggedIn);
Foursquared foursquared = (Foursquared) getApplication();
if (loggedIn) {
sendBroadcast(new Intent(Foursquared.INTENT_ACTION_LOGGED_IN));
Toast.makeText(LoginActivity.this, getString(R.string.login_welcome_toast),
Toast.LENGTH_LONG).show();
// Launch the service to update any widgets, etc.
foursquared.requestStartService();
// Launch the main activity to let the user do anything.
Intent intent = new Intent(LoginActivity.this, MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
// Be done with the activity.
finish();
} else {
sendBroadcast(new Intent(Foursquared.INTENT_ACTION_LOGGED_OUT));
NotificationsUtil.ToastReasonForFailure(LoginActivity.this, mReason);
}
dismissProgressDialog();
}
@Override
protected void onCancelled() {
dismissProgressDialog();
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapActivity;
import com.google.android.maps.MapController;
import com.google.android.maps.MapView;
import com.google.android.maps.MyLocationOverlay;
import com.google.android.maps.OverlayItem;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.maps.CrashFixMyLocationOverlay;
import com.joelapenna.foursquared.maps.VenueItemizedOverlayWithIcons;
import com.joelapenna.foursquared.maps.VenueItemizedOverlayWithIcons.VenueItemizedOverlayTapListener;
import com.joelapenna.foursquared.util.GeoUtils;
import com.joelapenna.foursquared.util.UiUtil;
import com.joelapenna.foursquared.widget.MapCalloutView;
import android.content.Intent;
import android.location.Location;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Toast;
import java.util.ArrayList;
/**
* Takes an array of venues and shows them on a map.
*
* @date June 30, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class NearbyVenuesMapActivity extends MapActivity {
public static final String TAG = "NearbyVenuesMapActivity";
public static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String INTENT_EXTRA_VENUES = Foursquared.PACKAGE_NAME
+ ".NearbyVenuesMapActivity.INTENT_EXTRA_VENUES";
private StateHolder mStateHolder;
private String mTappedVenueId;
private MapCalloutView mCallout;
private MapView mMapView;
private MapController mMapController;
private ArrayList<VenueItemizedOverlayWithIcons> mVenueGroupOverlays =
new ArrayList<VenueItemizedOverlayWithIcons>();
private MyLocationOverlay mMyLocationOverlay;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.search_map_activity);
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
} else {
if (getIntent().hasExtra(INTENT_EXTRA_VENUES)) {
Parcelable[] parcelables = getIntent().getParcelableArrayExtra(
INTENT_EXTRA_VENUES);
Group<Venue> venues = new Group<Venue>();
for (int i = 0; i < parcelables.length; i++) {
venues.add((Venue)parcelables[i]);
}
mStateHolder = new StateHolder(venues);
} else {
Log.e(TAG, TAG + " requires venue array in intent extras.");
finish();
return;
}
}
ensureUi();
}
private void ensureUi() {
mMapView = (MapView) findViewById(R.id.mapView);
mMapView.setBuiltInZoomControls(true);
mMapController = mMapView.getController();
mMyLocationOverlay = new CrashFixMyLocationOverlay(this, mMapView);
mMapView.getOverlays().add(mMyLocationOverlay);
mCallout = (MapCalloutView) findViewById(R.id.map_callout);
mCallout.setVisibility(View.GONE);
mCallout.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(NearbyVenuesMapActivity.this, VenueActivity.class);
intent.setAction(Intent.ACTION_VIEW);
intent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_ID, mTappedVenueId);
startActivity(intent);
}
});
// One CheckinItemizedOverlay per group!
VenueItemizedOverlayWithIcons mappableVenuesOverlay = createMappableVenuesOverlay(
mStateHolder.getVenues());
if (mappableVenuesOverlay != null) {
mVenueGroupOverlays.add(mappableVenuesOverlay);
}
if (mVenueGroupOverlays.size() > 0) {
mMapView.getOverlays().addAll(mVenueGroupOverlays);
recenterMap();
} else {
Toast.makeText(this, getResources().getString(
R.string.friendsmapactivity_no_checkins), Toast.LENGTH_LONG).show();
finish();
}
}
@Override
public void onResume() {
super.onResume();
mMyLocationOverlay.enableMyLocation();
if (UiUtil.sdkVersion() > 3) {
mMyLocationOverlay.enableCompass();
}
}
@Override
public void onPause() {
super.onPause();
mMyLocationOverlay.disableMyLocation();
if (UiUtil.sdkVersion() > 3) {
mMyLocationOverlay.disableCompass();
}
}
@Override
protected boolean isRouteDisplayed() {
return false;
}
/**
* We can do something more fun here like create an overlay per category, so the user
* can hide parks and show only bars, for example.
*/
private VenueItemizedOverlayWithIcons createMappableVenuesOverlay(Group<Venue> venues) {
Group<Venue> mappableVenues = new Group<Venue>();
for (Venue it : venues) {
mappableVenues.add(it);
}
if (mappableVenues.size() > 0) {
VenueItemizedOverlayWithIcons overlay = new VenueItemizedOverlayWithIcons(
this,
((Foursquared) getApplication()).getRemoteResourceManager(),
getResources().getDrawable(R.drawable.pin_checkin_multiple),
mVenueOverlayTapListener);
overlay.setGroup(mappableVenues);
return overlay;
} else {
return null;
}
}
private void recenterMap() {
// Previously we'd try to zoom to span, but this gives us odd results a lot of times,
// so falling back to zoom at a fixed level.
GeoPoint center = mMyLocationOverlay.getMyLocation();
if (center != null) {
mMapController.animateTo(center);
mMapController.setZoom(14);
} else {
// Location overlay wasn't ready yet, try using last known geolocation from manager.
Location bestLocation = GeoUtils.getBestLastGeolocation(this);
if (bestLocation != null) {
mMapController.animateTo(GeoUtils.locationToGeoPoint(bestLocation));
mMapController.setZoom(14);
} else {
// We have no location information at all, so we'll just show the map at a high
// zoom level and the user can zoom in as they wish.
Venue venue = mStateHolder.getVenues().get(0);
mMapController.animateTo(new GeoPoint(
(int)(Float.valueOf(venue.getGeolat()) * 1E6),
(int)(Float.valueOf(venue.getGeolong()) * 1E6)));
mMapController.setZoom(8);
}
}
}
/**
* Handle taps on one of the pins.
*/
private VenueItemizedOverlayTapListener mVenueOverlayTapListener =
new VenueItemizedOverlayTapListener() {
@Override
public void onTap(OverlayItem itemSelected, OverlayItem itemLastSelected, Venue venue) {
mTappedVenueId = venue.getId();
mCallout.setTitle(venue.getName());
mCallout.setMessage(venue.getAddress());
mCallout.setVisibility(View.VISIBLE);
mMapController.animateTo(GeoUtils.stringLocationToGeoPoint(
venue.getGeolat(), venue.getGeolong()));
}
@Override
public void onTap(GeoPoint p, MapView mapView) {
mCallout.setVisibility(View.GONE);
}
};
private class StateHolder {
private Group<Venue> mVenues;
public StateHolder(Group<Venue> venues) {
mVenues = venues;
}
public Group<Venue> getVenues() {
return mVenues;
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.http.AbstractHttpApi;
import com.joelapenna.foursquared.util.NotificationsUtil;
import org.apache.http.HttpException;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpRequestInterceptor;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.AuthState;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.protocol.ClientContext;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.protocol.ExecutionContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;
import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.KeyEvent;
import android.webkit.WebView;
import java.io.IOException;
/**
* Displays a special in a webview. Ideally we could use WebView.setHttpAuthUsernamePassword(),
* but it is unfortunately not working. Instead we download the html content manually, then
* feed it to our webview. Not ideal and we should update this in the future.
*
* @date April 4, 2010.
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*
*/
public class SpecialWebViewActivity extends Activity
{
private static final String TAG = "WebViewActivity";
public static final String EXTRA_CREDENTIALS_USERNAME = Foursquared.PACKAGE_NAME
+ ".SpecialWebViewActivity.EXTRA_CREDENTIALS_USERNAME";
public static final String EXTRA_CREDENTIALS_PASSWORD = Foursquared.PACKAGE_NAME
+ ".SpecialWebViewActivity.EXTRA_CREDENTIALS_PASSWORD";
public static final String EXTRA_SPECIAL_ID = Foursquared.PACKAGE_NAME
+ ".SpecialWebViewActivity.EXTRA_SPECIAL_ID";
private WebView mWebView;
private StateHolder mStateHolder;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.special_webview_activity);
mWebView = (WebView)findViewById(R.id.webView);
mWebView.getSettings().setJavaScriptEnabled(true);
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivityForTask(this);
if (mStateHolder.getIsRunningTask() == false) {
mWebView.loadDataWithBaseURL("--", mStateHolder.getHtml(), "text/html", "utf-8", "");
}
} else {
mStateHolder = new StateHolder();
if (getIntent().getExtras() != null &&
getIntent().getExtras().containsKey(EXTRA_CREDENTIALS_USERNAME) &&
getIntent().getExtras().containsKey(EXTRA_CREDENTIALS_PASSWORD) &&
getIntent().getExtras().containsKey(EXTRA_SPECIAL_ID))
{
String username = getIntent().getExtras().getString(EXTRA_CREDENTIALS_USERNAME);
String password = getIntent().getExtras().getString(EXTRA_CREDENTIALS_PASSWORD);
String specialid = getIntent().getExtras().getString(EXTRA_SPECIAL_ID);
mStateHolder.startTask(this, username, password, specialid);
} else {
Log.e(TAG, TAG + " intent missing required extras parameters.");
finish();
}
}
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivityForTask(null);
return mStateHolder;
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if ((keyCode == KeyEvent.KEYCODE_BACK) && mWebView.canGoBack()) {
mWebView.goBack();
return true;
}
return super.onKeyDown(keyCode, event);
}
private void onTaskComplete(String html, Exception ex) {
mStateHolder.setIsRunningTask(false);
if (html != null) {
mStateHolder.setHtml(html);
mWebView.loadDataWithBaseURL("--", mStateHolder.getHtml(), "text/html", "utf-8", "");
} else {
NotificationsUtil.ToastReasonForFailure(this, ex);
}
}
private static class SpecialTask extends AsyncTask<String, Void, String> {
private SpecialWebViewActivity mActivity;
private Exception mReason;
public SpecialTask(SpecialWebViewActivity activity) {
mActivity = activity;
}
public void setActivity(SpecialWebViewActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
}
@Override
protected String doInBackground(String... params) {
String html = null;
try {
String username = params[0];
String password = params[1];
String specialid = params[2];
StringBuilder sbUrl = new StringBuilder(128);
sbUrl.append("https://api.foursquare.com/iphone/special?sid=");
sbUrl.append(specialid);
AuthScope authScope = new AuthScope("api.foursquare.com", 80);
DefaultHttpClient httpClient = AbstractHttpApi.createHttpClient();
httpClient.getCredentialsProvider().setCredentials(authScope,
new UsernamePasswordCredentials(username, password));
httpClient.addRequestInterceptor(preemptiveAuth, 0);
HttpGet httpGet = new HttpGet(sbUrl.toString());
try {
HttpResponse response = httpClient.execute(httpGet);
String responseText = EntityUtils.toString(response.getEntity());
html = responseText.replace("('/img", "('http://www.foursquare.com/img");
} catch (Exception e) {
mReason = e;
}
} catch (Exception e) {
mReason = e;
}
return html;
}
@Override
protected void onPostExecute(String html) {
if (mActivity != null) {
mActivity.onTaskComplete(html, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onTaskComplete(null, new Exception("Special task cancelled."));
}
}
private HttpRequestInterceptor preemptiveAuth = new HttpRequestInterceptor() {
@Override
public void process(final HttpRequest request, final HttpContext context)
throws HttpException, IOException {
AuthState authState = (AuthState)context.getAttribute(ClientContext.TARGET_AUTH_STATE);
CredentialsProvider credsProvider = (CredentialsProvider)context
.getAttribute(ClientContext.CREDS_PROVIDER);
HttpHost targetHost = (HttpHost)context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);
// If not auth scheme has been initialized yet
if (authState.getAuthScheme() == null) {
AuthScope authScope = new AuthScope(targetHost.getHostName(), targetHost.getPort());
org.apache.http.auth.Credentials creds = credsProvider.getCredentials(authScope);
if (creds != null) {
authState.setAuthScheme(new BasicScheme());
authState.setCredentials(creds);
}
}
}
};
}
private static class StateHolder {
private String mHtml;
private boolean mIsRunningTask;
private SpecialTask mTask;
public StateHolder() {
mIsRunningTask = false;
}
public void setHtml(String html) {
mHtml = html;
}
public String getHtml() {
return mHtml;
}
public void startTask(SpecialWebViewActivity activity,
String username,
String password,
String specialid)
{
mIsRunningTask = true;
mTask = new SpecialTask(activity);
mTask.execute(username, password, specialid);
}
public void setActivityForTask(SpecialWebViewActivity activity) {
if (mTask != null) {
mTask.setActivity(activity);
}
}
public void setIsRunningTask(boolean isRunningTipTask) {
mIsRunningTask = isRunningTipTask;
}
public boolean getIsRunningTask() {
return mIsRunningTask;
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Checkin;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.app.LoadableListActivity;
import com.joelapenna.foursquared.util.NotificationsUtil;
import com.joelapenna.foursquared.widget.HistoryListAdapter;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.AsyncTask;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
/**
* This only works for the currently authenticated user.
*
* @date March 9, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class UserHistoryActivity extends LoadableListActivity {
static final String TAG = "UserHistoryActivity";
public static final String EXTRA_USER_NAME = Foursquared.PACKAGE_NAME
+ ".UserHistoryActivity.EXTRA_USER_NAME";
private StateHolder mStateHolder;
private HistoryListAdapter mListAdapter;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivityForTaskFriends(this);
} else {
if (getIntent().hasExtra(EXTRA_USER_NAME)) {
mStateHolder = new StateHolder(getIntent().getStringExtra(EXTRA_USER_NAME));
mStateHolder.startTaskHistory(this);
} else {
Log.e(TAG, TAG + " requires username as intent extra.");
finish();
return;
}
}
ensureUi();
}
@Override
public void onPause() {
super.onPause();
if (isFinishing()) {
mStateHolder.cancelTasks();
unregisterReceiver(mLoggedOutReceiver);
}
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivityForTaskFriends(null);
return mStateHolder;
}
private void ensureUi() {
mListAdapter = new HistoryListAdapter(
this, ((Foursquared) getApplication()).getRemoteResourceManager());
mListAdapter.setGroup(mStateHolder.getHistory());
ListView listView = getListView();
listView.setAdapter(mListAdapter);
listView.setSmoothScrollbarEnabled(true);
listView.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> adapter, View view, int position, long arg3) {
Object obj = (Object)mListAdapter.getItem(position);
if (obj != null) {
startVenueActivity((Checkin)obj);
}
}
});
if (mStateHolder.getIsRunningHistoryTask()) {
setLoadingView();
} else if (mStateHolder.getFetchedOnce() && mStateHolder.getHistory().size() == 0) {
setEmptyView();
}
setTitle(getString(R.string.user_history_activity_title, mStateHolder.getUsername()));
}
@Override
public int getNoSearchResultsStringId() {
return R.string.user_history_activity_no_info;
}
private void onHistoryTaskComplete(Group<Checkin> group, Exception ex) {
mListAdapter = new HistoryListAdapter(
this, ((Foursquared) getApplication()).getRemoteResourceManager());
if (group != null) {
mStateHolder.setHistory(group);
mListAdapter.setGroup(mStateHolder.getHistory());
getListView().setAdapter(mListAdapter);
}
else {
mStateHolder.setHistory(new Group<Checkin>());
mListAdapter.setGroup(mStateHolder.getHistory());
getListView().setAdapter(mListAdapter);
NotificationsUtil.ToastReasonForFailure(this, ex);
}
mStateHolder.setIsRunningHistoryTask(false);
mStateHolder.setFetchedOnce(true);
// TODO: Can tighten this up by just calling ensureUI() probably.
if (mStateHolder.getHistory().size() == 0) {
setEmptyView();
}
}
private void startVenueActivity(Checkin checkin) {
if (checkin != null) {
if (checkin.getVenue() != null && !TextUtils.isEmpty(checkin.getVenue().getId())) {
Venue venue = checkin.getVenue();
Intent intent = new Intent(this, VenueActivity.class);
intent.setAction(Intent.ACTION_VIEW);
intent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_PARTIAL, venue);
startActivity(intent);
} else {
Log.e(TAG, "Venue has no ID to start venue activity.");
}
}
}
/**
* Gets friends of the current user we're working for.
*/
private static class HistoryTask extends AsyncTask<String, Void, Group<Checkin>> {
private UserHistoryActivity mActivity;
private Exception mReason;
public HistoryTask(UserHistoryActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
mActivity.setLoadingView();
}
@Override
protected Group<Checkin> doInBackground(String... params) {
try {
Foursquared foursquared = (Foursquared) mActivity.getApplication();
Foursquare foursquare = foursquared.getFoursquare();
// Prune out shouts for now.
Group<Checkin> history = foursquare.history("50", null);
Group<Checkin> venuesOnly = new Group<Checkin>();
for (Checkin it : history) {
if (it.getVenue() != null) {
venuesOnly.add(it);
}
}
return venuesOnly;
} catch (Exception e) {
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(Group<Checkin> checkins) {
if (mActivity != null) {
mActivity.onHistoryTaskComplete(checkins, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onHistoryTaskComplete(null, mReason);
}
}
public void setActivity(UserHistoryActivity activity) {
mActivity = activity;
}
}
private static class StateHolder {
private String mUsername;
private Group<Checkin> mHistory;
private HistoryTask mTaskHistory;
private boolean mIsRunningHistoryTask;
private boolean mFetchedOnce;
public StateHolder(String username) {
mUsername = username;
mIsRunningHistoryTask = false;
mFetchedOnce = false;
mHistory = new Group<Checkin>();
}
public String getUsername() {
return mUsername;
}
public Group<Checkin> getHistory() {
return mHistory;
}
public void setHistory(Group<Checkin> history) {
mHistory = history;
}
public void startTaskHistory(UserHistoryActivity activity) {
mIsRunningHistoryTask = true;
mTaskHistory = new HistoryTask(activity);
mTaskHistory.execute();
}
public void setActivityForTaskFriends(UserHistoryActivity activity) {
if (mTaskHistory != null) {
mTaskHistory.setActivity(activity);
}
}
public void setIsRunningHistoryTask(boolean isRunning) {
mIsRunningHistoryTask = isRunning;
}
public boolean getIsRunningHistoryTask() {
return mIsRunningHistoryTask;
}
public void setFetchedOnce(boolean fetchedOnce) {
mFetchedOnce = fetchedOnce;
}
public boolean getFetchedOnce() {
return mFetchedOnce;
}
public void cancelTasks() {
if (mTaskHistory != null) {
mTaskHistory.setActivity(null);
mTaskHistory.cancel(true);
}
}
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquare.types.Checkin;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquared.app.LoadableListActivityWithViewAndHeader;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.util.CheckinTimestampSort;
import com.joelapenna.foursquared.util.Comparators;
import com.joelapenna.foursquared.util.MenuUtils;
import com.joelapenna.foursquared.util.NotificationsUtil;
import com.joelapenna.foursquared.util.UiUtil;
import com.joelapenna.foursquared.widget.CheckinListAdapter;
import com.joelapenna.foursquared.widget.SegmentedButton;
import com.joelapenna.foursquared.widget.SegmentedButton.OnClickListenerSegmentedButton;
import com.joelapenna.foursquared.widget.SeparatedListAdapter;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.location.Location;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.SubMenu;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ScrollView;
import java.io.IOException;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;
/**
* @author Joe LaPenna (joe@joelapenna.com)
* @author Mark Wyszomierski (markww@gmail.com)
* -Added dummy location observer, new menu icon logic,
* links to new user activity (3/10/2010).
* -Sorting checkins by distance/time. (3/18/2010).
* -Added option to sort by server response, or by distance. (6/10/2010).
* -Reformatted/refactored. (9/22/2010).
*/
public class FriendsActivity extends LoadableListActivityWithViewAndHeader {
static final String TAG = "FriendsActivity";
static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final int CITY_RADIUS_IN_METERS = 20 * 1000; // 20km
private static final long SLEEP_TIME_IF_NO_LOCATION = 3000L;
private static final int MENU_GROUP_SEARCH = 0;
private static final int MENU_REFRESH = 1;
private static final int MENU_SHOUT = 2;
private static final int MENU_MORE = 3;
private static final int MENU_MORE_MAP = 20;
private static final int MENU_MORE_LEADERBOARD = 21;
private static final int SORT_METHOD_RECENT = 0;
private static final int SORT_METHOD_NEARBY = 1;
private StateHolder mStateHolder;
private SearchLocationObserver mSearchLocationObserver = new SearchLocationObserver();
private LinkedHashMap<Integer, String> mMenuMoreSubitems;
private SeparatedListAdapter mListAdapter;
private ViewGroup mLayoutEmpty;
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
if (getLastNonConfigurationInstance() != null) {
mStateHolder = (StateHolder) getLastNonConfigurationInstance();
mStateHolder.setActivity(this);
} else {
mStateHolder = new StateHolder();
mStateHolder.setSortMethod(SORT_METHOD_RECENT);
}
ensureUi();
Foursquared foursquared = (Foursquared)getApplication();
if (foursquared.isReady()) {
if (!mStateHolder.getRanOnce()) {
mStateHolder.startTask(this);
}
}
}
@Override
public void onResume() {
super.onResume();
((Foursquared) getApplication()).requestLocationUpdates(mSearchLocationObserver);
}
@Override
public void onPause() {
super.onPause();
((Foursquared) getApplication()).removeLocationUpdates(mSearchLocationObserver);
if (isFinishing()) {
mListAdapter.removeObserver();
unregisterReceiver(mLoggedOutReceiver);
mStateHolder.cancel();
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
menu.add(MENU_GROUP_SEARCH, MENU_REFRESH, Menu.NONE, R.string.refresh)
.setIcon(R.drawable.ic_menu_refresh);
menu.add(Menu.NONE, MENU_SHOUT, Menu.NONE, R.string.shout_action_label)
.setIcon(R.drawable.ic_menu_shout);
SubMenu menuMore = menu.addSubMenu(Menu.NONE, MENU_MORE, Menu.NONE, "More");
menuMore.setIcon(android.R.drawable.ic_menu_more);
for (Map.Entry<Integer, String> it : mMenuMoreSubitems.entrySet()) {
menuMore.add(it.getValue());
}
MenuUtils.addPreferencesToMenu(this, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_REFRESH:
mStateHolder.startTask(this);
return true;
case MENU_SHOUT:
Intent intent = new Intent(this, CheckinOrShoutGatherInfoActivity.class);
intent.putExtra(CheckinOrShoutGatherInfoActivity.INTENT_EXTRA_IS_SHOUT, true);
startActivity(intent);
return true;
case MENU_MORE:
// Submenu items generate id zero, but we check on item title below.
return true;
default:
if (item.getTitle().equals("Map")) {
Checkin[] checkins = (Checkin[])mStateHolder.getCheckins().toArray(
new Checkin[mStateHolder.getCheckins().size()]);
Intent intentMap = new Intent(FriendsActivity.this, FriendsMapActivity.class);
intentMap.putExtra(FriendsMapActivity.EXTRA_CHECKIN_PARCELS, checkins);
startActivity(intentMap);
return true;
} else if (item.getTitle().equals(mMenuMoreSubitems.get(MENU_MORE_LEADERBOARD))) {
startActivity(new Intent(FriendsActivity.this, StatsActivity.class));
return true;
}
break;
}
return super.onOptionsItemSelected(item);
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivity(null);
return mStateHolder;
}
@Override
public int getNoSearchResultsStringId() {
return R.string.no_friend_checkins;
}
private void ensureUi() {
SegmentedButton buttons = getHeaderButton();
buttons.clearButtons();
buttons.addButtons(
getString(R.string.friendsactivity_btn_recent),
getString(R.string.friendsactivity_btn_nearby));
if (mStateHolder.getSortMethod() == SORT_METHOD_RECENT) {
buttons.setPushedButtonIndex(0);
} else {
buttons.setPushedButtonIndex(1);
}
buttons.setOnClickListener(new OnClickListenerSegmentedButton() {
@Override
public void onClick(int index) {
if (index == 0) {
mStateHolder.setSortMethod(SORT_METHOD_RECENT);
} else {
mStateHolder.setSortMethod(SORT_METHOD_NEARBY);
}
ensureUiListView();
}
});
mMenuMoreSubitems = new LinkedHashMap<Integer, String>();
mMenuMoreSubitems.put(MENU_MORE_MAP, getResources().getString(
R.string.friendsactivity_menu_map));
mMenuMoreSubitems.put(MENU_MORE_LEADERBOARD, getResources().getString(
R.string.friendsactivity_menu_leaderboard));
ensureUiListView();
}
private void ensureUiListView() {
mListAdapter = new SeparatedListAdapter(this);
if (mStateHolder.getSortMethod() == SORT_METHOD_RECENT) {
sortCheckinsRecent(mStateHolder.getCheckins(), mListAdapter);
} else {
sortCheckinsDistance(mStateHolder.getCheckins(), mListAdapter);
}
ListView listView = getListView();
listView.setAdapter(mListAdapter);
listView.setDividerHeight(0);
listView.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
Checkin checkin = (Checkin) parent.getAdapter().getItem(position);
if (checkin.getUser() != null) {
Intent intent = new Intent(FriendsActivity.this, UserDetailsActivity.class);
intent.putExtra(UserDetailsActivity.EXTRA_USER_PARCEL, checkin.getUser());
intent.putExtra(UserDetailsActivity.EXTRA_SHOW_ADD_FRIEND_OPTIONS, true);
startActivity(intent);
}
}
});
// Prepare our no-results view. Something odd is going on with the layout parameters though.
// If we don't explicitly set the layout to be fill/fill after inflating, the layout jumps
// to a wrap/wrap layout. Furthermore, sdk 3 crashes with the original layout using two
// buttons in a horizontal LinearLayout.
LayoutInflater inflater = LayoutInflater.from(this);
if (UiUtil.sdkVersion() > 3) {
mLayoutEmpty = (ScrollView)inflater.inflate(
R.layout.friends_activity_empty, null);
Button btnAddFriends = (Button)mLayoutEmpty.findViewById(
R.id.friendsActivityEmptyBtnAddFriends);
btnAddFriends.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(FriendsActivity.this, AddFriendsActivity.class);
startActivity(intent);
}
});
Button btnFriendRequests = (Button)mLayoutEmpty.findViewById(
R.id.friendsActivityEmptyBtnFriendRequests);
btnFriendRequests.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(FriendsActivity.this, FriendRequestsActivity.class);
startActivity(intent);
}
});
} else {
// Inflation on 1.5 is causing a lot of issues, dropping full layout.
mLayoutEmpty = (ScrollView)inflater.inflate(
R.layout.friends_activity_empty_sdk3, null);
}
mLayoutEmpty.setLayoutParams(new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.FILL_PARENT, LinearLayout.LayoutParams.FILL_PARENT));
if (mListAdapter.getCount() == 0) {
setEmptyView(mLayoutEmpty);
}
if (mStateHolder.getIsRunningTask()) {
setProgressBarIndeterminateVisibility(true);
if (!mStateHolder.getRanOnce()) {
setLoadingView();
}
} else {
setProgressBarIndeterminateVisibility(false);
}
}
private void sortCheckinsRecent(Group<Checkin> checkins, SeparatedListAdapter listAdapter) {
// Sort all by timestamp first.
Collections.sort(checkins, Comparators.getCheckinRecencyComparator());
// We'll group in different section adapters based on some time thresholds.
Group<Checkin> recent = new Group<Checkin>();
Group<Checkin> today = new Group<Checkin>();
Group<Checkin> yesterday = new Group<Checkin>();
Group<Checkin> older = new Group<Checkin>();
Group<Checkin> other = new Group<Checkin>();
CheckinTimestampSort timestamps = new CheckinTimestampSort();
for (Checkin it : checkins) {
// If we can't parse the distance value, it's possible that we
// did not have a geolocation for the device at the time the
// search was run. In this case just assume this friend is nearby
// to sort them in the time buckets.
int meters = 0;
try {
meters = Integer.parseInt(it.getDistance());
} catch (NumberFormatException ex) {
if (DEBUG) Log.d(TAG, "Couldn't parse distance for checkin during friend search.");
meters = 0;
}
if (meters > CITY_RADIUS_IN_METERS) {
other.add(it);
} else {
try {
Date date = new Date(it.getCreated());
if (date.after(timestamps.getBoundaryRecent())) {
recent.add(it);
} else if (date.after(timestamps.getBoundaryToday())) {
today.add(it);
} else if (date.after(timestamps.getBoundaryYesterday())) {
yesterday.add(it);
} else {
older.add(it);
}
} catch (Exception ex) {
older.add(it);
}
}
}
if (recent.size() > 0) {
CheckinListAdapter adapter = new CheckinListAdapter(this,
((Foursquared) getApplication()).getRemoteResourceManager());
adapter.setGroup(recent);
listAdapter.addSection(getResources().getString(
R.string.friendsactivity_title_sort_recent), adapter);
}
if (today.size() > 0) {
CheckinListAdapter adapter = new CheckinListAdapter(this,
((Foursquared) getApplication()).getRemoteResourceManager());
adapter.setGroup(today);
listAdapter.addSection(getResources().getString(
R.string.friendsactivity_title_sort_today), adapter);
}
if (yesterday.size() > 0) {
CheckinListAdapter adapter = new CheckinListAdapter(this,
((Foursquared) getApplication()).getRemoteResourceManager());
adapter.setGroup(yesterday);
listAdapter.addSection(getResources().getString(
R.string.friendsactivity_title_sort_yesterday), adapter);
}
if (older.size() > 0) {
CheckinListAdapter adapter = new CheckinListAdapter(this,
((Foursquared) getApplication()).getRemoteResourceManager());
adapter.setGroup(older);
listAdapter.addSection(getResources().getString(
R.string.friendsactivity_title_sort_older), adapter);
}
if (other.size() > 0) {
CheckinListAdapter adapter = new CheckinListAdapter(this,
((Foursquared) getApplication()).getRemoteResourceManager());
adapter.setGroup(other);
listAdapter.addSection(getResources().getString(
R.string.friendsactivity_title_sort_other_city), adapter);
}
}
private void sortCheckinsDistance(Group<Checkin> checkins, SeparatedListAdapter listAdapter) {
Collections.sort(checkins, Comparators.getCheckinDistanceComparator());
Group<Checkin> nearby = new Group<Checkin>();
CheckinListAdapter adapter = new CheckinListAdapter(this,
((Foursquared) getApplication()).getRemoteResourceManager());
for (Checkin it : checkins) {
int meters = 0;
try {
meters = Integer.parseInt(it.getDistance());
} catch (NumberFormatException ex) {
if (DEBUG) Log.d(TAG, "Couldn't parse distance for checkin during friend search.");
meters = 0;
}
if (meters < CITY_RADIUS_IN_METERS) {
nearby.add(it);
}
}
if (nearby.size() > 0) {
adapter.setGroup(nearby);
listAdapter.addSection(getResources().getString(
R.string.friendsactivity_title_sort_distance), adapter);
}
}
private void onTaskStart() {
setProgressBarIndeterminateVisibility(true);
setLoadingView();
}
private void onTaskComplete(Group<Checkin> checkins, Exception ex) {
mStateHolder.setRanOnce(true);
mStateHolder.setIsRunningTask(false);
setProgressBarIndeterminateVisibility(false);
// Clear list for new batch.
mListAdapter.removeObserver();
mListAdapter.clear();
mListAdapter = new SeparatedListAdapter(this);
// User can sort by default (which is by checkin time), or just by distance.
if (checkins != null) {
mStateHolder.setCheckins(checkins);
if (mStateHolder.getSortMethod() == SORT_METHOD_RECENT) {
sortCheckinsRecent(checkins, mListAdapter);
} else {
sortCheckinsDistance(checkins, mListAdapter);
}
} else if (ex != null) {
mStateHolder.setCheckins(new Group<Checkin>());
NotificationsUtil.ToastReasonForFailure(this, ex);
}
if (mStateHolder.getCheckins().size() == 0) {
setEmptyView(mLayoutEmpty);
}
getListView().setAdapter(mListAdapter);
}
private static class TaskCheckins extends AsyncTask<Void, Void, Group<Checkin>> {
private Foursquared mFoursquared;
private FriendsActivity mActivity;
private Exception mException;
public TaskCheckins(FriendsActivity activity) {
mFoursquared = ((Foursquared) activity.getApplication());
mActivity = activity;
}
public void setActivity(FriendsActivity activity) {
mActivity = activity;
}
@Override
public Group<Checkin> doInBackground(Void... params) {
Group<Checkin> checkins = null;
try {
checkins = checkins();
} catch (Exception ex) {
mException = ex;
}
return checkins;
}
@Override
protected void onPreExecute() {
mActivity.onTaskStart();
}
@Override
public void onPostExecute(Group<Checkin> checkins) {
if (mActivity != null) {
mActivity.onTaskComplete(checkins, mException);
}
}
private Group<Checkin> checkins() throws FoursquareException, IOException {
// If we're the startup tab, it's likely that we won't have a geo location
// immediately. For now we can use this ugly method of sleeping for N
// seconds to at least let network location get a lock. We're only trying
// to discern between same-city, so we can even use LocationManager's
// getLastKnownLocation() method because we don't care if we're even a few
// miles off. The api endpoint doesn't require location, so still go ahead
// even if we can't find a location.
Location loc = mFoursquared.getLastKnownLocation();
if (loc == null) {
try { Thread.sleep(SLEEP_TIME_IF_NO_LOCATION); } catch (InterruptedException ex) {}
loc = mFoursquared.getLastKnownLocation();
}
Group<Checkin> checkins = mFoursquared.getFoursquare().checkins(LocationUtils
.createFoursquareLocation(loc));
Collections.sort(checkins, Comparators.getCheckinRecencyComparator());
return checkins;
}
}
private static class StateHolder {
private Group<Checkin> mCheckins;
private int mSortMethod;
private boolean mRanOnce;
private boolean mIsRunningTask;
private TaskCheckins mTaskCheckins;
public StateHolder() {
mRanOnce = false;
mIsRunningTask = false;
mCheckins = new Group<Checkin>();
}
public int getSortMethod() {
return mSortMethod;
}
public void setSortMethod(int sortMethod) {
mSortMethod = sortMethod;
}
public Group<Checkin> getCheckins() {
return mCheckins;
}
public void setCheckins(Group<Checkin> checkins) {
mCheckins = checkins;
}
public boolean getRanOnce() {
return mRanOnce;
}
public void setRanOnce(boolean ranOnce) {
mRanOnce = ranOnce;
}
public boolean getIsRunningTask() {
return mIsRunningTask;
}
public void setIsRunningTask(boolean isRunning) {
mIsRunningTask = isRunning;
}
public void setActivity(FriendsActivity activity) {
if (mIsRunningTask) {
mTaskCheckins.setActivity(activity);
}
}
public void startTask(FriendsActivity activity) {
if (!mIsRunningTask) {
mTaskCheckins = new TaskCheckins(activity);
mTaskCheckins.execute();
mIsRunningTask = true;
}
}
public void cancel() {
if (mIsRunningTask) {
mTaskCheckins.cancel(true);
mIsRunningTask = false;
}
}
}
/**
* This is really just a dummy observer to get the GPS running
* since this is the new splash page. After getting a fix, we
* might want to stop registering this observer thereafter so
* it doesn't annoy the user too much.
*/
private class SearchLocationObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.view.Display;
import android.view.WindowManager;
import android.webkit.WebView;
import android.widget.LinearLayout;
/**
* Shows a listing of what's changed between
*
* @date March 17, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class ChangelogActivity extends Activity {
private static final String CHANGELOG_HTML_FILE =
"file:///android_asset/changelog-en.html";
private WebView mWebViewChanges;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.changelog_activity);
ensureUi();
}
private void ensureUi() {
WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();
LinearLayout llMain = (LinearLayout)findViewById(R.id.layoutMain);
// We'll force the dialog to be a certain percentage height of the screen.
mWebViewChanges = new WebView(this);
mWebViewChanges.setLayoutParams(new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.FILL_PARENT,
(int)Math.floor(display.getHeight() * 0.5)));
mWebViewChanges.loadUrl(CHANGELOG_HTML_FILE);
llMain.addView(mWebViewChanges);
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareException;
import com.joelapenna.foursquare.types.Category;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Response;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.location.LocationUtils;
import com.joelapenna.foursquared.util.NotificationsUtil;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.content.DialogInterface.OnDismissListener;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.location.Address;
import android.location.Geocoder;
import android.location.Location;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
import java.io.IOException;
import java.util.List;
/**
* Allows the user to add a new venue. This activity can also be used to submit
* edits to an existing venue. Pass a venue parcelable using the EXTRA_VENUE_TO_EDIT
* key to put the activity into edit mode.
*
* @author Joe LaPenna (joe@joelapenna.com)
* @author Mark Wyszomierski (markww@gmail.com)
* -Added support for using this activity to edit existing venues (June 8, 2010).
*/
public class AddVenueActivity extends Activity {
private static final String TAG = "AddVenueActivity";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
public static final String EXTRA_VENUE_TO_EDIT = "com.joelapenna.foursquared.VenueParcel";
private static final double MINIMUM_ACCURACY_FOR_ADDRESS = 100.0;
private static final int DIALOG_PICK_CATEGORY = 1;
private static final int DIALOG_ERROR = 2;
private StateHolder mStateHolder;
private EditText mNameEditText;
private EditText mAddressEditText;
private EditText mCrossstreetEditText;
private EditText mCityEditText;
private EditText mStateEditText;
private EditText mZipEditText;
private EditText mPhoneEditText;
private Button mAddOrEditVenueButton;
private LinearLayout mCategoryLayout;
private ImageView mCategoryImageView;
private TextView mCategoryTextView;
private ProgressBar mCategoryProgressBar;
private ProgressDialog mDlgProgress;
private TextWatcher mNameFieldWatcher = new TextWatcher() {
@Override
public void afterTextChanged(Editable s) {
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
mAddOrEditVenueButton.setEnabled(canEnableSaveButton());
}
};
private BroadcastReceiver mLoggedOutReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Log.d(TAG, "onReceive: " + intent);
finish();
}
};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (DEBUG) Log.d(TAG, "onCreate()");
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.add_venue_activity);
registerReceiver(mLoggedOutReceiver, new IntentFilter(Foursquared.INTENT_ACTION_LOGGED_OUT));
mAddOrEditVenueButton = (Button) findViewById(R.id.addVenueButton);
mNameEditText = (EditText) findViewById(R.id.nameEditText);
mAddressEditText = (EditText) findViewById(R.id.addressEditText);
mCrossstreetEditText = (EditText) findViewById(R.id.crossstreetEditText);
mCityEditText = (EditText) findViewById(R.id.cityEditText);
mStateEditText = (EditText) findViewById(R.id.stateEditText);
mZipEditText = (EditText) findViewById(R.id.zipEditText);
mPhoneEditText = (EditText) findViewById(R.id.phoneEditText);
mCategoryLayout = (LinearLayout) findViewById(R.id.addVenueCategoryLayout);
mCategoryImageView = (ImageView) findViewById(R.id.addVenueCategoryIcon);
mCategoryTextView = (TextView) findViewById(R.id.addVenueCategoryTextView);
mCategoryProgressBar = (ProgressBar) findViewById(R.id.addVenueCategoryProgressBar);
mCategoryLayout.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
showDialog(DIALOG_PICK_CATEGORY);
}
});
mCategoryLayout.setEnabled(false);
mAddOrEditVenueButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
String name = mNameEditText.getText().toString();
String address = mAddressEditText.getText().toString();
String crossstreet = mCrossstreetEditText.getText().toString();
String city = mCityEditText.getText().toString();
String state = mStateEditText.getText().toString();
String zip = mZipEditText.getText().toString();
String phone = mPhoneEditText.getText().toString();
if (mStateHolder.getVenueBeingEdited() != null) {
if (TextUtils.isEmpty(name)) {
showDialogError(getResources().getString(
R.string.add_venue_activity_error_no_venue_name));
return;
} else if (TextUtils.isEmpty(address)) {
showDialogError(getResources().getString(
R.string.add_venue_activity_error_no_venue_address));
return;
} else if (TextUtils.isEmpty(city)) {
showDialogError(getResources().getString(
R.string.add_venue_activity_error_no_venue_city));
return;
} else if (TextUtils.isEmpty(state)) {
showDialogError(getResources().getString(
R.string.add_venue_activity_error_no_venue_state));
return;
}
}
mStateHolder.startTaskAddOrEditVenue(
AddVenueActivity.this,
new String[] {
name,
address,
crossstreet,
city,
state,
zip,
phone,
mStateHolder.getChosenCategory() != null ?
mStateHolder.getChosenCategory().getId() : ""
},
// If editing a venue, pass in its id.
mStateHolder.getVenueBeingEdited() != null ?
mStateHolder.getVenueBeingEdited().getId() : null);
}
});
mNameEditText.addTextChangedListener(mNameFieldWatcher);
Object retained = getLastNonConfigurationInstance();
if (retained != null && retained instanceof StateHolder) {
mStateHolder = (StateHolder) retained;
mStateHolder.setActivity(this);
setFields(mStateHolder.getAddressLookup());
setChosenCategory(mStateHolder.getChosenCategory());
if (mStateHolder.getCategories() != null && mStateHolder.getCategories().size() > 0) {
mCategoryLayout.setEnabled(true);
mCategoryProgressBar.setVisibility(View.GONE);
}
} else {
mStateHolder = new StateHolder();
mStateHolder.startTaskGetCategories(this);
// If passed the venue parcelable, then we are in 'edit' mode.
if (getIntent().getExtras() != null && getIntent().getExtras().containsKey(EXTRA_VENUE_TO_EDIT)) {
Venue venue = getIntent().getExtras().getParcelable(EXTRA_VENUE_TO_EDIT);
if (venue != null) {
mStateHolder.setVenueBeingEdited(venue);
setFields(venue);
setTitle(getResources().getString(R.string.add_venue_activity_label_edit_venue));
mAddOrEditVenueButton.setText(getResources().getString(
R.string.add_venue_activity_btn_submit_edits));
} else {
Log.e(TAG, "Null venue parcelable supplied at startup, will finish immediately.");
finish();
}
} else {
mStateHolder.startTaskAddressLookup(this);
}
}
}
@Override
public void onResume() {
super.onResume();
((Foursquared) getApplication()).requestLocationUpdates(true);
if (mStateHolder.getIsRunningTaskAddOrEditVenue()) {
startProgressBar();
}
}
@Override
public void onPause() {
super.onPause();
((Foursquared) getApplication()).removeLocationUpdates();
stopProgressBar();
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mLoggedOutReceiver);
}
@Override
public Object onRetainNonConfigurationInstance() {
mStateHolder.setActivity(null);
return mStateHolder;
}
private void showDialogError(String message) {
mStateHolder.setError(message);
showDialog(DIALOG_ERROR);
}
/**
* Set fields from an address lookup, only used when adding a venue. This is done
* to prepopulate some fields for the user.
*/
private void setFields(AddressLookup addressLookup) {
if (mStateHolder.getVenueBeingEdited() == null &&
addressLookup != null &&
addressLookup.getAddress() != null) {
// Don't fill in the street unless we're reasonably confident we
// know where the user is.
String address = addressLookup.getAddress().getAddressLine(0);
double accuracy = addressLookup.getLocation().getAccuracy();
if (address != null && (accuracy > 0.0 && accuracy < MINIMUM_ACCURACY_FOR_ADDRESS)) {
if (DEBUG) Log.d(TAG, "Accuracy good enough, setting address field.");
mAddressEditText.setText(address);
}
String city = addressLookup.getAddress().getLocality();
if (city != null) {
mCityEditText.setText(city);
}
String state = addressLookup.getAddress().getAdminArea();
if (state != null) {
mStateEditText.setText(state);
}
String zip = addressLookup.getAddress().getPostalCode();
if (zip != null) {
mZipEditText.setText(zip);
}
String phone = addressLookup.getAddress().getPhone();
if (phone != null) {
mPhoneEditText.setText(phone);
}
}
}
/**
* Set fields from an existing venue, this is only used when editing a venue.
*/
private void setFields(Venue venue) {
mNameEditText.setText(venue.getName());
mCrossstreetEditText.setText(venue.getCrossstreet());
mAddressEditText.setText(venue.getAddress());
mCityEditText.setText(venue.getCity());
mStateEditText.setText(venue.getState());
mZipEditText.setText(venue.getZip());
mPhoneEditText.setText(venue.getPhone());
}
private void startProgressBar() {
startProgressBar(
getResources().getString(
mStateHolder.getVenueBeingEdited() == null ?
R.string.add_venue_progress_bar_message_add_venue :
R.string.add_venue_progress_bar_message_edit_venue));
}
private void startProgressBar(String message) {
if (mDlgProgress == null) {
mDlgProgress = ProgressDialog.show(this, null, message);
}
mDlgProgress.show();
}
private void stopProgressBar() {
if (mDlgProgress != null) {
mDlgProgress.dismiss();
mDlgProgress = null;
}
}
private void onGetCategoriesTaskComplete(Group<Category> categories, Exception ex) {
mStateHolder.setIsRunningTaskGetCategories(false);
try {
// Populate the categories list now.
if (categories != null) {
mStateHolder.setCategories(categories);
mCategoryLayout.setEnabled(true);
mCategoryTextView.setText(getResources().getString(R.string.add_venue_activity_pick_category_label));
mCategoryProgressBar.setVisibility(View.GONE);
// If we are editing a venue, set its category here.
if (mStateHolder.getVenueBeingEdited() != null) {
Venue venue = mStateHolder.getVenueBeingEdited();
if (venue.getCategory() != null) {
setChosenCategory(venue.getCategory());
}
}
} else {
// If error, feed list adapter empty user group.
mStateHolder.setCategories(new Group<Category>());
NotificationsUtil.ToastReasonForFailure(this, ex);
}
} finally {
}
stopIndeterminateProgressBar();
}
private void ooGetAddressLookupTaskComplete(AddressLookup addressLookup, Exception ex) {
mStateHolder.setIsRunningTaskAddressLookup(false);
stopIndeterminateProgressBar();
if (addressLookup != null) {
mStateHolder.setAddressLookup(addressLookup);
setFields(addressLookup);
} else {
// Nothing to do on failure, don't need to report.
}
}
private void onAddOrEditVenueTaskComplete(Venue venue, String venueIdIfEditing, Exception ex) {
mStateHolder.setIsRunningTaskAddOrEditVenue(false);
stopProgressBar();
if (venueIdIfEditing == null) {
if (venue != null) {
// If they added the venue ok, then send them to an activity displaying it
// so they can play around with it.
Intent intent = new Intent(AddVenueActivity.this, VenueActivity.class);
intent.putExtra(VenueActivity.INTENT_EXTRA_VENUE_PARTIAL, venue);
startActivity(intent);
finish();
} else {
// Error, let them hang out here.
NotificationsUtil.ToastReasonForFailure(this, ex);
}
} else {
if (venue != null) {
// Editing the venue worked ok, just return to caller.
Toast.makeText(this, getResources().getString(
R.string.add_venue_activity_edit_venue_success),
Toast.LENGTH_SHORT).show();
finish();
} else {
// Error, let them hang out here.
NotificationsUtil.ToastReasonForFailure(this, ex);
}
}
}
private void stopIndeterminateProgressBar() {
if (mStateHolder.getIsRunningTaskAddressLookup() == false &&
mStateHolder.getIsRunningTaskGetCategories() == false) {
setProgressBarIndeterminateVisibility(false);
}
}
private static class AddOrEditVenueTask extends AsyncTask<Void, Void, Venue> {
private AddVenueActivity mActivity;
private String[] mParams;
private String mVenueIdIfEditing;
private Exception mReason;
private Foursquared mFoursquared;
private String mErrorMsgForEditVenue;
public AddOrEditVenueTask(AddVenueActivity activity,
String[] params,
String venueIdIfEditing) {
mActivity = activity;
mParams = params;
mVenueIdIfEditing = venueIdIfEditing;
mFoursquared = (Foursquared) activity.getApplication();
mErrorMsgForEditVenue = activity.getResources().getString(
R.string.add_venue_activity_edit_venue_fail);
}
public void setActivity(AddVenueActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
mActivity.startProgressBar();
}
@Override
protected Venue doInBackground(Void... params) {
try {
Foursquare foursquare = mFoursquared.getFoursquare();
Location location = mFoursquared.getLastKnownLocationOrThrow();
if (mVenueIdIfEditing == null) {
return foursquare.addVenue(
mParams[0], // name
mParams[1], // address
mParams[2], // cross street
mParams[3], // city
mParams[4], // state,
mParams[5], // zip
mParams[6], // phone
mParams[7], // category id
LocationUtils.createFoursquareLocation(location));
} else {
Response response =
foursquare.proposeedit(
mVenueIdIfEditing,
mParams[0], // name
mParams[1], // address
mParams[2], // cross street
mParams[3], // city
mParams[4], // state,
mParams[5], // zip
mParams[6], // phone
mParams[7], // category id
LocationUtils.createFoursquareLocation(location));
if (response != null && response.getValue().equals("ok")) {
// TODO: Come up with a better method than returning an empty venue on success.
return new Venue();
} else {
throw new Exception(mErrorMsgForEditVenue);
}
}
} catch (Exception e) {
Log.e(TAG, "Exception during add or edit venue.", e);
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(Venue venue) {
if (DEBUG) Log.d(TAG, "onPostExecute()");
if (mActivity != null) {
mActivity.onAddOrEditVenueTaskComplete(venue, mVenueIdIfEditing, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onAddOrEditVenueTaskComplete(null, mVenueIdIfEditing, mReason);
}
}
}
private static class AddressLookupTask extends AsyncTask<Void, Void, AddressLookup> {
private AddVenueActivity mActivity;
private Exception mReason;
public AddressLookupTask(AddVenueActivity activity) {
mActivity = activity;
}
public void setActivity(AddVenueActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
mActivity.setProgressBarIndeterminateVisibility(true);
}
@Override
protected AddressLookup doInBackground(Void... params) {
try {
Location location = ((Foursquared)mActivity.getApplication()).getLastKnownLocationOrThrow();
Geocoder geocoder = new Geocoder(mActivity);
List<Address> addresses = geocoder.getFromLocation(location.getLatitude(), location.getLongitude(), 1);
if (addresses != null && addresses.size() > 0) {
Log.i(TAG, "Address found: " + addresses.toString());
return new AddressLookup(location, addresses.get(0));
} else {
Log.i(TAG, "No address could be found for current location.");
throw new FoursquareException("No address could be found for the current geolocation.");
}
} catch (Exception ex) {
Log.e(TAG, "Error during address lookup.", ex);
mReason = ex;
}
return null;
}
@Override
protected void onPostExecute(AddressLookup address) {
if (mActivity != null) {
mActivity.ooGetAddressLookupTaskComplete(address, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.ooGetAddressLookupTaskComplete(null, mReason);
}
}
}
private static class GetCategoriesTask extends AsyncTask<Void, Void, Group<Category>> {
private AddVenueActivity mActivity;
private Exception mReason;
public GetCategoriesTask(AddVenueActivity activity) {
mActivity = activity;
}
public void setActivity(AddVenueActivity activity) {
mActivity = activity;
}
@Override
protected void onPreExecute() {
mActivity.setProgressBarIndeterminateVisibility(true);
}
@Override
protected Group<Category> doInBackground(Void... params) {
try {
Foursquared foursquared = (Foursquared) mActivity.getApplication();
Foursquare foursquare = foursquared.getFoursquare();
return foursquare.categories();
} catch (Exception e) {
if (DEBUG)
Log.d(TAG, "GetCategoriesTask: Exception doing send friend request.", e);
mReason = e;
}
return null;
}
@Override
protected void onPostExecute(Group<Category> categories) {
if (DEBUG) Log.d(TAG, "GetCategoriesTask: onPostExecute()");
if (mActivity != null) {
mActivity.onGetCategoriesTaskComplete(categories, mReason);
}
}
@Override
protected void onCancelled() {
if (mActivity != null) {
mActivity.onGetCategoriesTaskComplete(null,
new Exception("Get categories task request cancelled."));
}
}
}
private static class StateHolder {
private AddressLookupTask mTaskGetAddress;
private AddressLookup mAddressLookup;
private boolean mIsRunningTaskAddressLookup;
private GetCategoriesTask mTaskGetCategories;
private Group<Category> mCategories;
private boolean mIsRunningTaskGetCategories;
private AddOrEditVenueTask mTaskAddOrEditVenue;
private boolean mIsRunningTaskAddOrEditVenue;
private Category mChosenCategory;
private Venue mVenueBeingEdited;
private String mError;
public StateHolder() {
mCategories = new Group<Category>();
mIsRunningTaskAddressLookup = false;
mIsRunningTaskGetCategories = false;
mIsRunningTaskAddOrEditVenue = false;
mVenueBeingEdited = null;
}
public void setCategories(Group<Category> categories) {
mCategories = categories;
}
public void setAddressLookup(AddressLookup addressLookup) {
mAddressLookup = addressLookup;
}
public Group<Category> getCategories() {
return mCategories;
}
public AddressLookup getAddressLookup() {
return mAddressLookup;
}
public Venue getVenueBeingEdited() {
return mVenueBeingEdited;
}
public void setVenueBeingEdited(Venue venue) {
mVenueBeingEdited = venue;
}
public void startTaskGetCategories(AddVenueActivity activity) {
mIsRunningTaskGetCategories = true;
mTaskGetCategories = new GetCategoriesTask(activity);
mTaskGetCategories.execute();
}
public void startTaskAddressLookup(AddVenueActivity activity) {
mIsRunningTaskAddressLookup = true;
mTaskGetAddress = new AddressLookupTask(activity);
mTaskGetAddress.execute();
}
public void startTaskAddOrEditVenue(AddVenueActivity activity, String[] params,
String venueIdIfEditing) {
mIsRunningTaskAddOrEditVenue = true;
mTaskAddOrEditVenue = new AddOrEditVenueTask(activity, params, venueIdIfEditing);
mTaskAddOrEditVenue.execute();
}
public void setActivity(AddVenueActivity activity) {
if (mTaskGetCategories != null) {
mTaskGetCategories.setActivity(activity);
}
if (mTaskGetAddress != null) {
mTaskGetAddress.setActivity(activity);
}
if (mTaskAddOrEditVenue != null) {
mTaskAddOrEditVenue.setActivity(activity);
}
}
public void setIsRunningTaskAddressLookup(boolean isRunning) {
mIsRunningTaskAddressLookup = isRunning;
}
public void setIsRunningTaskGetCategories(boolean isRunning) {
mIsRunningTaskGetCategories = isRunning;
}
public void setIsRunningTaskAddOrEditVenue(boolean isRunning) {
mIsRunningTaskAddOrEditVenue = isRunning;
}
public boolean getIsRunningTaskAddressLookup() {
return mIsRunningTaskAddressLookup;
}
public boolean getIsRunningTaskGetCategories() {
return mIsRunningTaskGetCategories;
}
public boolean getIsRunningTaskAddOrEditVenue() {
return mIsRunningTaskAddOrEditVenue;
}
public Category getChosenCategory() {
return mChosenCategory;
}
public void setChosenCategory(Category category) {
mChosenCategory = category;
}
public String getError() {
return mError;
}
public void setError(String error) {
mError = error;
}
}
private static class AddressLookup {
private Location mLocation;
private Address mAddress;
public AddressLookup(Location location, Address address) {
mLocation = location;
mAddress = address;
}
public Location getLocation() {
return mLocation;
}
public Address getAddress() {
return mAddress;
}
}
@Override
protected Dialog onCreateDialog(int id) {
switch (id) {
case DIALOG_PICK_CATEGORY:
// When the user cancels the dialog (by hitting the 'back' key), we
// finish this activity. We don't listen to onDismiss() for this
// action, because a device rotation will fire onDismiss(), and our
// dialog would not be re-displayed after the rotation is complete.
CategoryPickerDialog dlg = new CategoryPickerDialog(
this,
mStateHolder.getCategories(),
((Foursquared)getApplication()));
dlg.setOnCancelListener(new OnCancelListener() {
@Override
public void onCancel(DialogInterface dialog) {
CategoryPickerDialog dlg = (CategoryPickerDialog)dialog;
setChosenCategory(dlg.getChosenCategory());
removeDialog(DIALOG_PICK_CATEGORY);
}
});
return dlg;
case DIALOG_ERROR:
AlertDialog dlgInfo = new AlertDialog.Builder(this)
.setIcon(0)
.setTitle(getResources().getString(R.string.add_venue_progress_bar_title_edit_venue))
.setMessage(mStateHolder.getError()).create();
dlgInfo.setOnDismissListener(new OnDismissListener() {
public void onDismiss(DialogInterface dialog) {
removeDialog(DIALOG_ERROR);
}
});
return dlgInfo;
}
return null;
}
private void setChosenCategory(Category category) {
if (category == null) {
mCategoryTextView.setText(getResources().getString(
R.string.add_venue_activity_pick_category_label));
return;
}
try {
Bitmap bitmap = BitmapFactory.decodeStream(
((Foursquared)getApplication()).getRemoteResourceManager().getInputStream(
Uri.parse(category.getIconUrl())));
mCategoryImageView.setImageBitmap(bitmap);
} catch (IOException e) {
if (DEBUG) Log.e(TAG, "Error loading category icon.", e);
}
mCategoryTextView.setText(category.getNodeName());
// Record the chosen category.
mStateHolder.setChosenCategory(category);
if (canEnableSaveButton()) {
mAddOrEditVenueButton.setEnabled(canEnableSaveButton());
}
}
private boolean canEnableSaveButton() {
return mNameEditText.getText().length() > 0;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import com.joelapenna.foursquared.util.UserUtils;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
/**
* @date September 25, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public class FriendActionableListAdapter extends BaseGroupAdapter<User>
implements ObservableAdapter {
private LayoutInflater mInflater;
private int mLayoutToInflate;
private ButtonRowClickHandler mClickListener;
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
private Handler mHandler = new Handler();
private int mLoadedPhotoIndex;
public FriendActionableListAdapter(Context context, ButtonRowClickHandler clickListener,
RemoteResourceManager rrm) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = R.layout.friend_actionable_list_item;
mClickListener = clickListener;
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mLoadedPhotoIndex = 0;
mRrm.addObserver(mResourcesObserver);
}
public FriendActionableListAdapter(Context context, int layoutResource) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = layoutResource;
}
public void removeObserver() {
mHandler.removeCallbacks(mRunnableLoadPhotos);
mHandler.removeCallbacks(mUpdatePhotos);
mRrm.deleteObserver(mResourcesObserver);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
holder = new ViewHolder();
holder.photo = (ImageView) convertView.findViewById(R.id.photo);
holder.name = (TextView) convertView.findViewById(R.id.name);
holder.btn1 = (Button) convertView.findViewById(R.id.btn1);
holder.btn2 = (Button) convertView.findViewById(R.id.btn2);
convertView.setTag(holder);
holder.btn1.setOnClickListener(mOnClickListenerBtn1);
holder.btn2.setOnClickListener(mOnClickListenerBtn2);
} else {
holder = (ViewHolder) convertView.getTag();
}
User user = (User) getItem(position);
final Uri photoUri = Uri.parse(user.getPhoto());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.photo.setImageBitmap(bitmap);
} catch (IOException e) {
if (Foursquare.MALE.equals(user.getGender())) {
holder.photo.setImageResource(R.drawable.blank_boy);
} else {
holder.photo.setImageResource(R.drawable.blank_girl);
}
}
holder.name.setText(user.getFirstname() + " "
+ (user.getLastname() != null ? user.getLastname() : ""));
if (UserUtils.isFollower(user)) {
holder.btn1.setVisibility(View.VISIBLE);
holder.btn2.setVisibility(View.VISIBLE);
holder.btn1.setTag(user);
holder.btn2.setTag(user);
} else {
// Eventually we may have items for this case, like 'delete friend'.
holder.btn1.setVisibility(View.GONE);
holder.btn2.setVisibility(View.GONE);
}
return convertView;
}
private OnClickListener mOnClickListenerBtn1 = new OnClickListener() {
@Override
public void onClick(View v) {
if (mClickListener != null) {
User user = (User) v.getTag();
mClickListener.onBtnClickBtn1(user);
}
}
};
private OnClickListener mOnClickListenerBtn2 = new OnClickListener() {
@Override
public void onClick(View v) {
if (mClickListener != null) {
User user = (User) v.getTag();
mClickListener.onBtnClickBtn2(user);
}
}
};
public void removeItem(int position) throws IndexOutOfBoundsException {
group.remove(position);
notifyDataSetInvalidated();
}
@Override
public void setGroup(Group<User> g) {
super.setGroup(g);
mLoadedPhotoIndex = 0;
mHandler.postDelayed(mRunnableLoadPhotos, 10L);
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
mHandler.post(mUpdatePhotos);
}
}
private Runnable mUpdatePhotos = new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
};
private Runnable mRunnableLoadPhotos = new Runnable() {
@Override
public void run() {
if (mLoadedPhotoIndex < getCount()) {
User user = (User)getItem(mLoadedPhotoIndex++);
Uri photoUri = Uri.parse(user.getPhoto());
if (!mRrm.exists(photoUri)) {
mRrm.request(photoUri);
}
mHandler.postDelayed(mRunnableLoadPhotos, 200L);
}
}
};
static class ViewHolder {
ImageView photo;
TextView name;
Button btn1;
Button btn2;
}
public interface ButtonRowClickHandler {
public void onBtnClickBtn1(User user);
public void onBtnClickBtn2(User user);
}
}
| Java |
/**
* Copyright 2008 Joe LaPenna
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Mayor;
import android.content.Context;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public abstract class BaseMayorAdapter extends BaseGroupAdapter<Mayor> {
public BaseMayorAdapter(Context context) {
super(context);
}
}
| Java |
/**
* Copyright 2008 Joe LaPenna
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Venue;
import android.content.Context;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
abstract public class BaseVenueAdapter extends BaseGroupAdapter<Venue> {
public BaseVenueAdapter(Context context) {
super(context);
}
}
| Java |
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Checkin;
import com.joelapenna.foursquare.types.FoursquareType;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import com.joelapenna.foursquared.util.UserUtils;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.net.Uri;
import android.util.AttributeSet;
import android.view.View;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;
/**
* A single horizontal strip of user photo views. Expected to be used from
* xml resource, needs more work to make this a robust and generic control.
*
* @date September 15, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class PhotoStrip extends View
implements ObservableAdapter {
private int mPhotoSize;
private int mPhotoSpacing;
private int mPhotoBorder;
private int mPhotoBorderStroke;
private int mPhotoBorderColor;
private int mPhotoBorderStrokeColor;
private Group<User> mTypes;
private Map<String, Bitmap> mCachedBitmaps = new HashMap<String, Bitmap>();
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
public PhotoStrip(Context context) {
super(context);
}
public PhotoStrip(Context context, AttributeSet attrs) {
super(context, attrs);
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.PhotoStrip, 0, 0);
mPhotoSize = a.getDimensionPixelSize(R.styleable.PhotoStrip_photoSize, 44);
mPhotoSpacing = a.getDimensionPixelSize(R.styleable.PhotoStrip_photoSpacing, 10);
mPhotoBorder = a.getDimensionPixelSize(R.styleable.PhotoStrip_photoBorder, 2);
mPhotoBorderStroke = a.getDimensionPixelSize(R.styleable.PhotoStrip_photoBorderStroke, 0);
mPhotoBorderColor = a.getColor(R.styleable.PhotoStrip_photoBorderColor, 0xFFFFFFFF);
mPhotoBorderStrokeColor = a.getColor(R.styleable.PhotoStrip_photoBorderStrokeColor, 0xFFD0D0D);
a.recycle();
}
public void setUsersAndRemoteResourcesManager(Group<User> users, RemoteResourceManager rrm) {
mTypes = users;
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
invalidate();
}
public void setCheckinsAndRemoteResourcesManager(Group<Checkin> checkins, RemoteResourceManager rrm) {
Group<User> users = new Group<User>();
for (Checkin it : checkins) {
if (it.getUser() != null) {
users.add(it.getUser());
}
}
setUsersAndRemoteResourcesManager(users, rrm);
}
public void removeObserver() {
mRrm.deleteObserver(mResourcesObserver);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
if (mRrm != null && mResourcesObserver != null) {
mRrm.deleteObserver(mResourcesObserver);
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
Paint paint = new Paint(Paint.FILTER_BITMAP_FLAG);
paint.setAntiAlias(true);
int width = getWidth();
int sum = mPhotoSize + mPhotoSpacing;
int index = 0;
while (sum < width) {
if (mTypes == null || index >= mTypes.size()) {
break;
}
Rect rcDst = new Rect(
index * (mPhotoSize + mPhotoSpacing),
0,
index * (mPhotoSize + mPhotoSpacing) + mPhotoSize,
mPhotoSize);
paint.setColor(mPhotoBorderStrokeColor);
canvas.drawRect(rcDst, paint);
rcDst.inset(mPhotoBorderStroke, mPhotoBorderStroke);
paint.setColor(mPhotoBorderColor);
canvas.drawRect(rcDst, paint);
rcDst.inset(mPhotoBorder, mPhotoBorder);
FoursquareType type = mTypes.get(index);
Bitmap bmp = fetchBitmapForUser(type);
if (bmp != null) {
Rect rcSrc = new Rect(0, 0, bmp.getWidth(), bmp.getHeight());
canvas.drawBitmap(bmp, rcSrc, rcDst, paint);
}
sum += (mPhotoSize + mPhotoSpacing);
index++;
}
}
private Bitmap fetchBitmapForUser(FoursquareType type) {
User user = null;
if (type instanceof User) {
user = (User)type;
} else if (type instanceof Checkin) {
Checkin checkin = (Checkin)type;
user = checkin.getUser();
if (user == null) {
return null;
}
} else {
throw new RuntimeException("PhotoStrip can only accept Users or Checkins.");
}
String photoUrl = user.getPhoto();
if (mCachedBitmaps.containsKey(photoUrl)) {
return mCachedBitmaps.get(photoUrl);
}
Uri uriPhoto = Uri.parse(photoUrl);
if (mRrm.exists(uriPhoto)) {
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(Uri.parse(photoUrl)));
mCachedBitmaps.put(photoUrl, bitmap);
return bitmap;
} catch (IOException e) {
}
} else {
mRrm.request(uriPhoto);
}
return BitmapFactory.decodeResource(getResources(), UserUtils.getDrawableByGenderForUserThumbnail(user));
}
/**
* @see android.view.View#measure(int, int)
*/
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(
measureWidth(widthMeasureSpec),
measureHeight(heightMeasureSpec));
}
/**
* Determines the width of this view
* @param measureSpec A measureSpec packed into an int
* @return The width of the view, honoring constraints from measureSpec
*/
private int measureWidth(int measureSpec) {
int result = 0;
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);
if (specMode == MeasureSpec.EXACTLY) {
// We were told how big to be.
result = specSize;
}
else {
if (specMode == MeasureSpec.AT_MOST) {
// Use result.
}
else {
// Use result.
}
}
return result;
}
private int measureHeight(int measureSpec) {
// We should be exactly as high as the specified photo size.
// An exception would be if we have zero photos to display,
// we're not dealing with that at the moment.
return mPhotoSize + getPaddingTop() + getPaddingBottom();
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
postInvalidate();
}
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Tip;
import com.joelapenna.foursquare.types.Todo;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import com.joelapenna.foursquared.util.StringFormatters;
import com.joelapenna.foursquared.util.TipUtils;
import com.joelapenna.foursquared.util.UiUtil;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;
/**
* @date September 12, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class TodosListAdapter extends BaseGroupAdapter<Todo>
implements ObservableAdapter {
private LayoutInflater mInflater;
private int mLayoutToInflate;
private Resources mResources;
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
private Handler mHandler = new Handler();
private int mLoadedPhotoIndex;
private Map<String, String> mCachedTimestamps;
private boolean mDisplayVenueTitles;
private int mSdk;
public TodosListAdapter(Context context, RemoteResourceManager rrm) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = R.layout.todo_list_item;
mResources = context.getResources();
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mLoadedPhotoIndex = 0;
mCachedTimestamps = new HashMap<String, String>();
mDisplayVenueTitles = true;
mSdk = UiUtil.sdkVersion();
mRrm.addObserver(mResourcesObserver);
}
public void removeObserver() {
mHandler.removeCallbacks(mUpdatePhotos);
mHandler.removeCallbacks(mRunnableLoadPhotos);
mRrm.deleteObserver(mResourcesObserver);
}
public TodosListAdapter(Context context, int layoutResource) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = layoutResource;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unnecessary
// calls to findViewById() on each row.
ViewHolder holder;
// When convertView is not null, we can reuse it directly, there is no
// need to re-inflate it. We only inflate a new View when the
// convertView supplied by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
holder.photo = (ImageView) convertView.findViewById(R.id.ivVenueCategory);
holder.title = (TextView) convertView.findViewById(R.id.tvTitle);
holder.body = (TextView) convertView.findViewById(R.id.tvBody);
holder.dateAndAuthor = (TextView) convertView.findViewById(R.id.tvDateAndAuthor);
holder.corner = (ImageView) convertView.findViewById(R.id.ivTipCorner);
convertView.setTag(holder);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder) convertView.getTag();
}
Todo todo = (Todo)getItem(position);
Tip tip = todo.getTip();
if (tip != null) {
if (mDisplayVenueTitles && tip.getVenue() != null) {
holder.title.setText("@ " + tip.getVenue().getName());
holder.title.setVisibility(View.VISIBLE);
} else {
holder.title.setVisibility(View.GONE);
holder.body.setPadding(
holder.body.getPaddingLeft(), holder.title.getPaddingTop(),
holder.body.getPaddingRight(), holder.body.getPaddingBottom());
}
if (tip.getVenue() != null && tip.getVenue().getCategory() != null) {
Uri photoUri = Uri.parse(tip.getVenue().getCategory().getIconUrl());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.photo.setImageBitmap(bitmap);
} catch (IOException e) {
holder.photo.setImageResource(R.drawable.category_none);
}
} else {
holder.photo.setImageResource(R.drawable.category_none);
}
if (!TextUtils.isEmpty(tip.getText())) {
holder.body.setText(tip.getText());
holder.body.setVisibility(View.VISIBLE);
} else {
if (mSdk > 3) {
holder.body.setVisibility(View.GONE);
} else {
holder.body.setText("");
holder.body.setVisibility(View.INVISIBLE);
}
}
if (tip.getUser() != null) {
holder.dateAndAuthor.setText(
holder.dateAndAuthor.getText() +
mResources.getString(
R.string.tip_age_via,
StringFormatters.getUserFullName(tip.getUser())));
}
if (TipUtils.isDone(tip)) {
holder.corner.setVisibility(View.VISIBLE);
holder.corner.setImageResource(R.drawable.tip_list_item_corner_done);
} else if (TipUtils.isTodo(tip)) {
holder.corner.setVisibility(View.VISIBLE);
holder.corner.setImageResource(R.drawable.tip_list_item_corner_todo);
} else {
holder.corner.setVisibility(View.GONE);
}
} else {
holder.title.setText("");
holder.body.setText("");
holder.corner.setVisibility(View.VISIBLE);
holder.corner.setImageResource(R.drawable.tip_list_item_corner_todo);
holder.photo.setImageResource(R.drawable.category_none);
}
holder.dateAndAuthor.setText(mResources.getString(
R.string.todo_added_date,
mCachedTimestamps.get(todo.getId())));
return convertView;
}
public void removeItem(int position) throws IndexOutOfBoundsException {
group.remove(position);
notifyDataSetInvalidated();
}
@Override
public void setGroup(Group<Todo> g) {
super.setGroup(g);
mLoadedPhotoIndex = 0;
mHandler.postDelayed(mRunnableLoadPhotos, 10L);
mCachedTimestamps.clear();
for (Todo it : g) {
String formatted = StringFormatters.getTipAge(mResources, it.getCreated());
mCachedTimestamps.put(it.getId(), formatted);
}
}
public void setDisplayTodoVenueTitles(boolean displayTodoVenueTitles) {
mDisplayVenueTitles = displayTodoVenueTitles;
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
mHandler.post(mUpdatePhotos);
}
}
private Runnable mUpdatePhotos = new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
};
private Runnable mRunnableLoadPhotos = new Runnable() {
@Override
public void run() {
if (mLoadedPhotoIndex < getCount()) {
Todo todo = (Todo)getItem(mLoadedPhotoIndex++);
if (todo.getTip() != null && todo.getTip().getVenue() != null) {
Venue venue = todo.getTip().getVenue();
if (venue.getCategory() != null) {
Uri photoUri = Uri.parse(venue.getCategory().getIconUrl());
if (!mRrm.exists(photoUri)) {
mRrm.request(photoUri);
}
mHandler.postDelayed(mRunnableLoadPhotos, 200L);
}
}
}
}
};
static class ViewHolder {
ImageView photo;
TextView title;
TextView body;
TextView dateAndAuthor;
ImageView corner;
}
}
| Java |
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Category;
import com.joelapenna.foursquared.FoursquaredSettings;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import java.io.File;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
public class CategoryPickerAdapter extends BaseAdapter implements ObservableAdapter {
private static final String TAG = "CheckinListAdapter";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private LayoutInflater mInflater;
private int mLayoutToInflate;
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
private Handler mHandler = new Handler();
private Category mCategory;
public CategoryPickerAdapter(Context context, RemoteResourceManager rrm, Category category) {
super();
mCategory = category;
mInflater = LayoutInflater.from(context);
mLayoutToInflate = R.layout.category_picker_list_item;
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
for (Category it : mCategory.getChildCategories()) {
Uri photoUri = Uri.parse(it.getIconUrl());
File file = mRrm.getFile(photoUri);
if (file != null) {
if (System.currentTimeMillis() - file.lastModified() > FoursquaredSettings.CATEGORY_ICON_EXPIRATION) {
mRrm.invalidate(photoUri);
file = null;
}
}
if (file == null) {
mRrm.request(photoUri);
}
}
}
public void removeObserver() {
mRrm.deleteObserver(mResourcesObserver);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unnecessary
// calls to findViewById() on each row.
ViewHolder holder;
// When convertView is not null, we can reuse it directly, there is no
// need to re-inflate it. We only inflate a new View when the
// convertView supplied by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
holder.icon = (ImageView) convertView.findViewById(R.id.categoryPickerIcon);
holder.name = (TextView) convertView.findViewById(R.id.categoryPickerName);
holder.disclosure = (ImageView) convertView.findViewById(R.id.categoryPickerIconDisclosure);
convertView.setTag(holder);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder) convertView.getTag();
}
Category category = (Category) getItem(position);
final Uri photoUri = Uri.parse(category.getIconUrl());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.icon.setImageBitmap(bitmap);
} catch (IOException e) {
if (DEBUG) Log.e(TAG, "Error loading category icon.", e);
}
if (category.getChildCategories() != null && category.getChildCategories().size() > 0) {
holder.disclosure.setVisibility(View.VISIBLE);
} else {
holder.disclosure.setVisibility(View.GONE);
}
holder.name.setText(category.getNodeName());
return convertView;
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
mHandler.post(new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
});
}
}
private static class ViewHolder {
ImageView icon;
TextView name;
ImageView disclosure;
}
@Override
public int getCount() {
return mCategory.getChildCategories().size();
}
@Override
public Object getItem(int position) {
return mCategory.getChildCategories().get(position);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public boolean hasStableIds() {
return true;
}
public static class CategoryFlat {
private Category mCategory;
private int mDepth;
public CategoryFlat(Category category, int depth) {
mCategory = category;
mDepth = depth;
}
public Category getCategory() {
return mCategory;
}
public int getDepth() {
return mDepth;
}
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Badge;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquared.FoursquaredSettings;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class BadgeWithIconListAdapter extends BadgeListAdapter
implements ObservableAdapter {
private static final String TAG = "BadgeWithIconListAdapter";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private RemoteResourceManager mRrm;
private Handler mHandler = new Handler();
private RemoteResourceManagerObserver mResourcesObserver;
/**
* @param context
* @param venues
*/
public BadgeWithIconListAdapter(Context context, RemoteResourceManager rrm) {
super(context);
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
}
public BadgeWithIconListAdapter(Context context, RemoteResourceManager rrm, int layoutResource) {
super(context, layoutResource);
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
}
public void removeObserver() {
mRrm.deleteObserver(mResourcesObserver);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
View view = super.getView(position, convertView, parent);
Badge badge = (Badge)getItem(position);
ImageView icon = ((BadgeWithIconListAdapter.ViewHolder)view.getTag()).icon;
try {
Bitmap bitmap = BitmapFactory.decodeStream(//
mRrm.getInputStream(Uri.parse(badge.getIcon())));
icon.setImageBitmap(bitmap);
} catch (IOException e) {
if (DEBUG) Log.d(TAG, "Could not load bitmap. We don't have it yet.");
icon.setImageResource(R.drawable.default_on);
}
return view;
}
@Override
public void setGroup(Group<Badge> g) {
super.setGroup(g);
for (int i = 0; i < group.size(); i++) {
Uri photoUri = Uri.parse((group.get(i)).getIcon());
if (!mRrm.exists(photoUri)) {
mRrm.request(photoUri);
}
}
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
if (DEBUG) Log.d(TAG, "Fetcher got: " + data);
mHandler.post(new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
});
}
}
}
| Java |
/**
* Copyright 2008 Joe LaPenna
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Mayor;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.FoursquaredSettings;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class MayorListAdapter extends BaseMayorAdapter implements ObservableAdapter {
private static final String TAG = "MayorListAdapter";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private LayoutInflater mInflater;
private RemoteResourceManager mRrm;
private Handler mHandler = new Handler();
private RemoteResourceManagerObserver mResourcesObserver;
public MayorListAdapter(Context context, RemoteResourceManager rrm) {
super(context);
mInflater = LayoutInflater.from(context);
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
}
public void removeObserver() {
mRrm.deleteObserver(mResourcesObserver);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unnecessary
// calls to findViewById() on each row.
final ViewHolder holder;
// When convertView is not null, we can reuse it directly, there is no
// need to re-inflate it. We only inflate a new View when the
// convertView supplied by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(R.layout.mayor_list_item, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
holder.photo = (ImageView)convertView.findViewById(R.id.photo);
holder.firstLine = (TextView)convertView.findViewById(R.id.firstLine);
holder.secondLine = (TextView)convertView.findViewById(R.id.mayorMessageTextView);
convertView.setTag(holder);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder)convertView.getTag();
}
Mayor mayor = (Mayor)getItem(position);
final User user = mayor.getUser();
final Uri photoUri = Uri.parse(user.getPhoto());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.photo.setImageBitmap(bitmap);
} catch (IOException e) {
if (Foursquare.MALE.equals(user.getGender())) {
holder.photo.setImageResource(R.drawable.blank_boy);
} else {
holder.photo.setImageResource(R.drawable.blank_girl);
}
}
holder.firstLine.setText(mayor.getUser().getFirstname());
holder.secondLine.setText(mayor.getMessage());
return convertView;
}
@Override
public void setGroup(Group<Mayor> g) {
super.setGroup(g);
for (int i = 0; i < g.size(); i++) {
Uri photoUri = Uri.parse((g.get(i)).getUser().getPhoto());
if (!mRrm.exists(photoUri)) {
mRrm.request(photoUri);
}
}
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
if (DEBUG) Log.d(TAG, "Fetcher got: " + data);
mHandler.post(new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
});
}
}
private static class ViewHolder {
ImageView photo;
TextView firstLine;
TextView secondLine;
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Tip;
import android.content.Context;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
abstract public class BaseTipAdapter extends BaseGroupAdapter<Tip> {
public BaseTipAdapter(Context context) {
super(context);
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Category;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Tip;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import com.joelapenna.foursquared.util.StringFormatters;
import com.joelapenna.foursquared.util.TipUtils;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;
/**
* @date August 31, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public class TipsListAdapter extends BaseGroupAdapter<Tip>
implements ObservableAdapter {
private LayoutInflater mInflater;
private int mLayoutToInflate;
private Resources mResources;
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
private Handler mHandler = new Handler();
private int mLoadedPhotoIndex;
private boolean mDisplayTipVenueTitles;
private Map<String, String> mCachedTimestamps;
public TipsListAdapter(Context context, RemoteResourceManager rrm, int layout) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = layout;
mResources = context.getResources();
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mLoadedPhotoIndex = 0;
mDisplayTipVenueTitles = true;
mCachedTimestamps = new HashMap<String, String>();
mRrm.addObserver(mResourcesObserver);
}
public void removeObserver() {
mHandler.removeCallbacks(mUpdatePhotos);
mHandler.removeCallbacks(mRunnableLoadPhotos);
mRrm.deleteObserver(mResourcesObserver);
}
public TipsListAdapter(Context context, int layoutResource) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = layoutResource;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unnecessary
// calls to findViewById() on each row.
ViewHolder holder;
// When convertView is not null, we can reuse it directly, there is no
// need to re-inflate it. We only inflate a new View when the
// convertView supplied by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
holder.photo = (ImageView) convertView.findViewById(R.id.icon);
holder.title = (TextView) convertView.findViewById(R.id.tvTitle);
holder.body = (TextView) convertView.findViewById(R.id.tvBody);
holder.dateAndAuthor = (TextView) convertView.findViewById(R.id.tvDateAndAuthor);
//holder.friendCountTodoImg = (ImageView) convertView.findViewById(R.id.ivFriendCountAsTodo);
//holder.friendCountTodo = (TextView) convertView.findViewById(R.id.tvFriendCountAsTodo);
holder.friendCountCompletedImg = (ImageView) convertView.findViewById(R.id.ivFriendCountCompleted);
holder.friendCountCompleted = (TextView) convertView.findViewById(R.id.tvFriendCountCompleted);
holder.corner = (ImageView) convertView.findViewById(R.id.ivTipCorner);
convertView.setTag(holder);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder) convertView.getTag();
}
Tip tip = (Tip) getItem(position);
User user = tip.getUser();
if (user != null) {
Uri photoUri = Uri.parse(user.getPhoto());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.photo.setImageBitmap(bitmap);
} catch (IOException e) {
if (Foursquare.MALE.equals(user.getGender())) {
holder.photo.setImageResource(R.drawable.blank_boy);
} else {
holder.photo.setImageResource(R.drawable.blank_girl);
}
}
} else {
Venue venue = tip.getVenue();
Category category = venue.getCategory();
if (category != null) {
holder.photo.setBackgroundDrawable(null);
Uri photoUri = Uri.parse(category.getIconUrl());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.photo.setImageBitmap(bitmap);
} catch (IOException e) {
holder.photo.setImageResource(R.drawable.category_none);
}
} else {
// If there is no category for this venue, fall back to the original
// method of the
// blue/grey pin depending on if the user has been there or not.
holder.photo.setImageResource(R.drawable.category_none);
}
}
if (mDisplayTipVenueTitles && tip.getVenue() != null) {
holder.title.setText("@ " + tip.getVenue().getName());
holder.title.setVisibility(View.VISIBLE);
} else {
holder.title.setVisibility(View.GONE);
holder.body.setPadding(
holder.body.getPaddingLeft(), holder.title.getPaddingTop(),
holder.body.getPaddingRight(), holder.title.getPaddingBottom());
}
holder.body.setText(tip.getText());
holder.dateAndAuthor.setText(mCachedTimestamps.get(tip.getId()));
if (user != null) {
holder.dateAndAuthor.setText(
holder.dateAndAuthor.getText() +
mResources.getString(
R.string.tip_age_via,
StringFormatters.getUserFullName(user)));
}
/*
if (tip.getStats().getTodoCount() > 0) {
holder.friendCountTodoImg.setVisibility(View.VISIBLE);
holder.friendCountTodo.setVisibility(View.VISIBLE);
holder.friendCountTodo.setText(String.valueOf(tip.getStats().getTodoCount()));
} else {
holder.friendCountTodoImg.setVisibility(View.GONE);
holder.friendCountTodo.setVisibility(View.GONE);
}
*/
if (tip.getStats().getDoneCount() > 0) {
holder.friendCountCompletedImg.setVisibility(View.VISIBLE);
holder.friendCountCompleted.setVisibility(View.VISIBLE);
holder.friendCountCompleted.setText(String.valueOf(tip.getStats().getDoneCount()));
} else {
holder.friendCountCompletedImg.setVisibility(View.GONE);
holder.friendCountCompleted.setVisibility(View.GONE);
}
if (TipUtils.isDone(tip)) {
holder.corner.setVisibility(View.VISIBLE);
holder.corner.setImageResource(R.drawable.tip_list_item_corner_done);
} else if (TipUtils.isTodo(tip)) {
holder.corner.setVisibility(View.VISIBLE);
holder.corner.setImageResource(R.drawable.tip_list_item_corner_todo);
} else {
holder.corner.setVisibility(View.GONE);
}
return convertView;
}
public void removeItem(int position) throws IndexOutOfBoundsException {
group.remove(position);
notifyDataSetInvalidated();
}
@Override
public void setGroup(Group<Tip> g) {
super.setGroup(g);
mLoadedPhotoIndex = 0;
mHandler.postDelayed(mRunnableLoadPhotos, 10L);
mCachedTimestamps.clear();
for (Tip it : g) {
String formatted = StringFormatters.getTipAge(mResources, it.getCreated());
mCachedTimestamps.put(it.getId(), formatted);
}
}
public void setDisplayTipVenueTitles(boolean displayTipVenueTitles) {
mDisplayTipVenueTitles = displayTipVenueTitles;
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
mHandler.post(mUpdatePhotos);
}
}
private Runnable mUpdatePhotos = new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
};
private Runnable mRunnableLoadPhotos = new Runnable() {
@Override
public void run() {
if (mLoadedPhotoIndex < getCount()) {
Tip tip = (Tip)getItem(mLoadedPhotoIndex++);
if (tip.getUser() != null) {
Uri photoUri = Uri.parse(tip.getUser().getPhoto());
if (!mRrm.exists(photoUri)) {
mRrm.request(photoUri);
}
mHandler.postDelayed(mRunnableLoadPhotos, 200L);
}
}
}
};
static class ViewHolder {
ImageView photo;
TextView title;
TextView body;
TextView dateAndAuthor;
//ImageView friendCountTodoImg;
//TextView friendCountTodo;
ImageView friendCountCompletedImg;
TextView friendCountCompleted;
ImageView corner;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.UserUtils;
import android.content.Context;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import java.util.ArrayList;
/**
*
* @date September 23, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*
*/
public class UserContactAdapter extends BaseAdapter {
private LayoutInflater mInflater;
private int mLayoutToInflate;
private User mUser;
private ArrayList<Action> mActions;
public UserContactAdapter(Context context, User user) {
super();
mInflater = LayoutInflater.from(context);
mLayoutToInflate = R.layout.user_actions_list_item;
mUser = user;
mActions = new ArrayList<Action>();
if (user != null) {
if (UserUtils.isFriend(user)) {
if (TextUtils.isEmpty(mUser.getPhone()) == false) {
mActions.add(new Action(context.getResources().getString(
R.string.user_actions_activity_action_sms),
R.drawable.user_action_text, Action.ACTION_ID_SMS, false));
}
if (TextUtils.isEmpty(mUser.getEmail()) == false) {
mActions.add(new Action(context.getResources().getString(
R.string.user_actions_activity_action_email),
R.drawable.user_action_email, Action.ACTION_ID_EMAIL, false));
}
if (TextUtils.isEmpty(mUser.getEmail()) == false) {
mActions.add(new Action(context.getResources().getString(
R.string.user_actions_activity_action_phone),
R.drawable.user_action_phone, Action.ACTION_ID_PHONE, false));
}
}
if (TextUtils.isEmpty(mUser.getTwitter()) == false) {
mActions.add(new Action(context.getResources().getString(
R.string.user_actions_activity_action_twitter),
R.drawable.user_action_twitter, Action.ACTION_ID_TWITTER, true));
}
if (TextUtils.isEmpty(mUser.getFacebook()) == false) {
mActions.add(new Action(context.getResources().getString(
R.string.user_actions_activity_action_facebook),
R.drawable.user_action_facebook, Action.ACTION_ID_FACEBOOK, true));
}
}
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
}
ImageView iv = (ImageView) convertView.findViewById(R.id.userActionsListItemIcon);
TextView tv = (TextView) convertView.findViewById(R.id.userActionsListItemLabel);
Action action = (Action) getItem(position);
iv.setImageResource(action.getIconId());
tv.setText(action.getLabel());
return convertView;
}
@Override
public int getCount() {
return mActions.size();
}
@Override
public Object getItem(int position) {
return mActions.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
public static class Action {
public static final int ACTION_ID_SMS = 0;
public static final int ACTION_ID_EMAIL = 1;
public static final int ACTION_ID_PHONE = 2;
public static final int ACTION_ID_TWITTER = 3;
public static final int ACTION_ID_FACEBOOK = 4;
private String mLabel;
private int mIconId;
private int mActionId;
private boolean mIsExternalAction;
public Action(String label, int iconId, int actionId, boolean isExternalAction) {
mLabel = label;
mIconId = iconId;
mActionId = actionId;
mIsExternalAction = isExternalAction;
}
public String getLabel() {
return mLabel;
}
public int getIconId() {
return mIconId;
}
public int getActionId() {
return mActionId;
}
public boolean getIsExternalAction() {
return mIsExternalAction;
}
}
} | Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquared.R;
import android.app.Activity;
import android.content.Context;
import android.util.AttributeSet;
import android.widget.LinearLayout;
import android.widget.TextView;
/**
* @date June 24, 2010
* @author Mark Wyszomierski (mark@gmail.com)
*/
public class MapCalloutView extends LinearLayout {
private TextView mTextViewTitle;
private TextView mTextViewMessage;
public MapCalloutView(Context context) {
super(context);
}
public MapCalloutView(Context context, AttributeSet attrs) {
super(context, attrs);
}
@Override
public void onFinishInflate() {
super.onFinishInflate();
((Activity)getContext()).getLayoutInflater().inflate(R.layout.map_callout_view, this);
mTextViewTitle = (TextView)findViewById(R.id.title);
mTextViewMessage = (TextView)findViewById(R.id.message);
}
public void setTitle(String title) {
mTextViewTitle.setText(title);
}
public void setMessage(String message) {
mTextViewMessage.setText(message);
}
}
| Java |
/**
* Copyright 2008 Joe LaPenna
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Special;
import com.joelapenna.foursquared.R;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
/**
* @author avolovoy
*/
public class SpecialListAdapter extends BaseGroupAdapter<Special> {
private LayoutInflater mInflater;
private int mLayoutToInflate;
public SpecialListAdapter(Context context) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = R.layout.special_list_item;
}
public SpecialListAdapter(Context context, int layoutResource) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = layoutResource;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unnecessary
// calls to findViewById() on each row.
ViewHolder holder;
// When convertView is not null, we can reuse it directly, there is no
// need to re-inflate it. We only inflate a new View when the
// convertView supplied by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
// holder.icon = (ImageView)convertView.findViewById(R.id.icon);
holder.message = (TextView)convertView.findViewById(R.id.message);
convertView.setTag(holder);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder)convertView.getTag();
}
Special special = (Special)getItem(position);
holder.message.setText(special.getMessage());
return convertView;
}
static class ViewHolder {
// ImageView icon;
TextView message;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.FoursquaredSettings;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
/**
* @date February 14, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public class FriendSearchAddFriendAdapter extends BaseGroupAdapter<User> implements
ObservableAdapter {
private static final String TAG = "";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private LayoutInflater mInflater;
private int mLayoutToInflate;
private ButtonRowClickHandler mClickListener;
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
private Handler mHandler = new Handler();
public FriendSearchAddFriendAdapter(Context context, ButtonRowClickHandler clickListener,
RemoteResourceManager rrm) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = R.layout.add_friends_list_item;
mClickListener = clickListener;
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
}
public void removeObserver() {
mRrm.deleteObserver(mResourcesObserver);
}
public FriendSearchAddFriendAdapter(Context context, int layoutResource) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = layoutResource;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unnecessary
// calls to findViewById() on each row.
ViewHolder holder;
// When convertView is not null, we can reuse it directly, there is no
// need to re-inflate it. We only inflate a new View when the
// convertView supplied by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
holder.clickable = (LinearLayout) convertView
.findViewById(R.id.addFriendListItemClickableArea);
holder.photo = (ImageView) convertView.findViewById(R.id.addFriendListItemPhoto);
holder.name = (TextView) convertView.findViewById(R.id.addFriendListItemName);
holder.add = (Button) convertView.findViewById(R.id.addFriendListItemAddButton);
convertView.setTag(holder);
holder.clickable.setOnClickListener(mOnClickListenerInfo);
holder.add.setOnClickListener(mOnClickListenerAdd);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder) convertView.getTag();
}
User user = (User) getItem(position);
final Uri photoUri = Uri.parse(user.getPhoto());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.photo.setImageBitmap(bitmap);
} catch (IOException e) {
if (Foursquare.MALE.equals(user.getGender())) {
holder.photo.setImageResource(R.drawable.blank_boy);
} else {
holder.photo.setImageResource(R.drawable.blank_girl);
}
}
holder.clickable.setTag(new Integer(position));
holder.name.setText(user.getFirstname() + " "
+ (user.getLastname() != null ? user.getLastname() : ""));
holder.add.setTag(new Integer(position));
return convertView;
}
private OnClickListener mOnClickListenerAdd = new OnClickListener() {
@Override
public void onClick(View v) {
Integer position = (Integer) v.getTag();
mClickListener.onBtnClickAdd((User) getItem(position));
}
};
private OnClickListener mOnClickListenerInfo = new OnClickListener() {
@Override
public void onClick(View v) {
if (mClickListener != null) {
Integer position = (Integer) v.getTag();
mClickListener.onInfoAreaClick((User) getItem(position));
}
}
};
public void removeItem(int position) throws IndexOutOfBoundsException {
group.remove(position);
notifyDataSetInvalidated();
}
@Override
public void setGroup(Group<User> g) {
super.setGroup(g);
for (int i = 0; i < g.size(); i++) {
Uri photoUri = Uri.parse(g.get(i).getPhoto());
if (!mRrm.exists(photoUri)) {
mRrm.request(photoUri);
}
}
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
if (DEBUG) Log.d(TAG, "Fetcher got: " + data);
mHandler.post(new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
});
}
}
static class ViewHolder {
LinearLayout clickable;
ImageView photo;
TextView name;
Button add;
}
public interface ButtonRowClickHandler {
public void onBtnClickAdd(User user);
public void onInfoAreaClick(User user);
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.FoursquaredSettings;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
/**
* @date February 15, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public class FriendRequestsAdapter extends BaseGroupAdapter<User>
implements ObservableAdapter {
private static final String TAG = "FriendRequestsAdapter";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private LayoutInflater mInflater;
private int mLayoutToInflate;
private ButtonRowClickHandler mClickListener;
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
private Handler mHandler = new Handler();
private int mLoadedPhotoIndex;
public FriendRequestsAdapter(Context context, ButtonRowClickHandler clickListener,
RemoteResourceManager rrm) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = R.layout.friend_request_list_item;
mClickListener = clickListener;
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mLoadedPhotoIndex = 0;
mRrm.addObserver(mResourcesObserver);
}
public FriendRequestsAdapter(Context context, int layoutResource) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = layoutResource;
}
public void removeObserver() {
mHandler.removeCallbacks(mRunnableLoadPhotos);
mRrm.deleteObserver(mResourcesObserver);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unnecessary
// calls to findViewById() on each row.
ViewHolder holder;
// When convertView is not null, we can reuse it directly, there is no
// need to re-inflate it. We only inflate a new View when the
// convertView supplied by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
holder.photo = (ImageView) convertView.findViewById(R.id.friendRequestListItemPhoto);
holder.name = (TextView) convertView.findViewById(R.id.friendRequestListItemName);
holder.add = (Button) convertView.findViewById(R.id.friendRequestApproveButton);
holder.ignore = (Button) convertView.findViewById(R.id.friendRequestDenyButton);
holder.clickable = (LinearLayout) convertView.findViewById(R.id.friendRequestListItemClickableArea);
convertView.setTag(holder);
holder.clickable.setOnClickListener(mOnClickListenerInfo);
holder.add.setOnClickListener(mOnClickListenerApprove);
holder.ignore.setOnClickListener(mOnClickListenerDeny);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder) convertView.getTag();
}
User user = (User) getItem(position);
final Uri photoUri = Uri.parse(user.getPhoto());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.photo.setImageBitmap(bitmap);
} catch (IOException e) {
if (Foursquare.MALE.equals(user.getGender())) {
holder.photo.setImageResource(R.drawable.blank_boy);
} else {
holder.photo.setImageResource(R.drawable.blank_girl);
}
}
holder.name.setText(user.getFirstname() + " "
+ (user.getLastname() != null ? user.getLastname() : ""));
holder.clickable.setTag(new Integer(position));
holder.add.setTag(new Integer(position));
holder.ignore.setTag(new Integer(position));
return convertView;
}
private OnClickListener mOnClickListenerInfo = new OnClickListener() {
@Override
public void onClick(View v) {
Integer position = (Integer) v.getTag();
mClickListener.onInfoAreaClick((User) getItem(position));
}
};
private OnClickListener mOnClickListenerApprove = new OnClickListener() {
@Override
public void onClick(View v) {
Integer position = (Integer) v.getTag();
mClickListener.onBtnClickAdd((User) getItem(position));
}
};
private OnClickListener mOnClickListenerDeny = new OnClickListener() {
@Override
public void onClick(View v) {
if (mClickListener != null) {
Integer position = (Integer) v.getTag();
mClickListener.onBtnClickIgnore((User) getItem(position));
}
}
};
public void removeItem(int position) throws IndexOutOfBoundsException {
group.remove(position);
notifyDataSetInvalidated();
}
@Override
public void setGroup(Group<User> g) {
super.setGroup(g);
mLoadedPhotoIndex = 0;
mHandler.postDelayed(mRunnableLoadPhotos, 10L);
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
if (DEBUG) Log.d(TAG, "Fetcher got: " + data);
mHandler.post(new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
});
}
}
private Runnable mRunnableLoadPhotos = new Runnable() {
@Override
public void run() {
if (mLoadedPhotoIndex < getCount()) {
User user = (User)getItem(mLoadedPhotoIndex++);
Uri photoUri = Uri.parse(user.getPhoto());
if (!mRrm.exists(photoUri)) {
mRrm.request(photoUri);
}
mHandler.postDelayed(mRunnableLoadPhotos, 200L);
}
}
};
static class ViewHolder {
LinearLayout clickable;
ImageView photo;
TextView name;
Button add;
Button ignore;
}
public interface ButtonRowClickHandler {
public void onInfoAreaClick(User user);
public void onBtnClickAdd(User user);
public void onBtnClickIgnore(User user);
}
}
| Java |
/**
* Copyright 2008 Joe LaPenna
*/
package com.joelapenna.foursquared.widget;
import android.content.Context;
import android.widget.BaseAdapter;
import com.joelapenna.foursquare.types.FoursquareType;
import com.joelapenna.foursquare.types.Group;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
abstract class BaseGroupAdapter<T extends FoursquareType> extends BaseAdapter {
Group<T> group = null;
public BaseGroupAdapter(Context context) {
}
@Override
public int getCount() {
return (group == null) ? 0 : group.size();
}
@Override
public Object getItem(int position) {
return group.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public boolean hasStableIds() {
return true;
}
@Override
public boolean isEmpty() {
return (group == null) ? true : group.isEmpty();
}
public void setGroup(Group<T> g) {
group = g;
notifyDataSetInvalidated();
}
}
| Java |
/**
* Copyright 2008 Joe LaPenna
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Category;
import com.joelapenna.foursquare.types.Group;
import com.joelapenna.foursquare.types.Stats;
import com.joelapenna.foursquare.types.Venue;
import com.joelapenna.foursquared.FoursquaredSettings;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import com.joelapenna.foursquared.util.StringFormatters;
import com.joelapenna.foursquared.util.VenueUtils;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.text.TextUtils;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import java.io.File;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
public class VenueListAdapter extends BaseVenueAdapter implements ObservableAdapter {
private static final String TAG = "VenueListAdapter";
private static final boolean DEBUG = FoursquaredSettings.DEBUG;
private LayoutInflater mInflater;
private RemoteResourceManager mRrm;
private Handler mHandler;
private RemoteResourceManagerObserver mResourcesObserver;
public VenueListAdapter(Context context, RemoteResourceManager rrm) {
super(context);
mInflater = LayoutInflater.from(context);
mHandler = new Handler();
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
}
public void removeObserver() {
mRrm.deleteObserver(mResourcesObserver);
}
/**
* Make a view to hold each row.
*
* @see android.widget.ListAdapter#getView(int, android.view.View,
* android.view.ViewGroup)
*/
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unnecessary
// calls to findViewById() on each row.
ViewHolder holder;
// When convertView is not null, we can reuse it directly, there is no
// need to re-inflate it. We only inflate a new View when the
// convertView supplied by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(R.layout.venue_list_item, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
holder.icon = (ImageView) convertView.findViewById(R.id.icon);
holder.venueName = (TextView) convertView.findViewById(R.id.venueName);
holder.locationLine1 = (TextView) convertView.findViewById(R.id.venueLocationLine1);
holder.iconSpecial = (ImageView) convertView.findViewById(R.id.iconSpecialHere);
holder.venueDistance = (TextView) convertView.findViewById(R.id.venueDistance);
holder.iconTrending = (ImageView) convertView.findViewById(R.id.iconTrending);
holder.venueCheckinCount = (TextView) convertView.findViewById(R.id.venueCheckinCount);
holder.todoHere = (ImageView) convertView.findViewById(R.id.venueTodoCorner);
convertView.setTag(holder);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder) convertView.getTag();
}
// Check if the venue category icon exists on disk, if not default to a
// venue pin icon.
Venue venue = (Venue) getItem(position);
Category category = venue.getCategory();
if (category != null) {
Uri photoUri = Uri.parse(category.getIconUrl());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.icon.setImageBitmap(bitmap);
} catch (IOException e) {
setDefaultVenueCategoryIcon(venue, holder);
}
} else {
// If there is no category for this venue, fall back to the original
// method of the
// blue/grey pin depending on if the user has been there or not.
setDefaultVenueCategoryIcon(venue, holder);
}
// Venue name.
holder.venueName.setText(venue.getName());
// Venue street address (cross streets | city, state zip).
if (!TextUtils.isEmpty(venue.getAddress())) {
holder.locationLine1.setText(StringFormatters.getVenueLocationFull(venue));
} else {
holder.locationLine1.setText("");
}
// If there's a special here, show the special here icon.
if (VenueUtils.getSpecialHere(venue)) {
holder.iconSpecial.setVisibility(View.VISIBLE);
} else {
holder.iconSpecial.setVisibility(View.GONE);
}
// Show venue distance.
if (venue.getDistance() != null) {
holder.venueDistance.setText(venue.getDistance() + " meters");
} else {
holder.venueDistance.setText("");
}
// If more than two people here, then show trending text.
Stats stats = venue.getStats();
if (stats != null &&
!stats.getHereNow().equals("0") &&
!stats.getHereNow().equals("1") &&
!stats.getHereNow().equals("2")) {
holder.iconTrending.setVisibility(View.VISIBLE);
holder.venueCheckinCount.setVisibility(View.VISIBLE);
holder.venueCheckinCount.setText(stats.getHereNow() + " people here");
} else {
holder.iconTrending.setVisibility(View.GONE);
holder.venueCheckinCount.setVisibility(View.GONE);
}
// If we have a todo here, show the corner folded over.
if (venue.getHasTodo()) {
holder.todoHere.setVisibility(View.VISIBLE);
} else {
holder.todoHere.setVisibility(View.INVISIBLE);
}
return convertView;
}
private void setDefaultVenueCategoryIcon(Venue venue, ViewHolder holder) {
holder.icon.setImageResource(R.drawable.category_none);
}
@Override
public void setGroup(Group<Venue> g) {
super.setGroup(g);
for (Venue it : g) {
// Start download of category icon if not already in the cache.
// At the same time, check the age of each of these images, if
// expired, delete and request a fresh copy. This should be
// removed once category icon set urls are versioned.
Category category = it.getCategory();
if (category != null) {
Uri photoUri = Uri.parse(category.getIconUrl());
File file = mRrm.getFile(photoUri);
if (file != null) {
if (System.currentTimeMillis() - file.lastModified() > FoursquaredSettings.CATEGORY_ICON_EXPIRATION) {
mRrm.invalidate(photoUri);
file = null;
}
}
if (file == null) {
mRrm.request(photoUri);
}
}
}
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
if (DEBUG) Log.d(TAG, "Fetcher got: " + data);
mHandler.post(new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
});
}
}
private static class ViewHolder {
ImageView icon;
TextView venueName;
TextView locationLine1;
ImageView iconSpecial;
TextView venueDistance;
ImageView iconTrending;
TextView venueCheckinCount;
ImageView todoHere;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Category;
import com.joelapenna.foursquare.types.Checkin;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import com.joelapenna.foursquared.util.StringFormatters;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import java.io.IOException;
import java.util.Observable;
import java.util.Observer;
/**
* @date March 9, 2010
* @author Mark Wyszomierski (markww@gmail.com)
*/
public class HistoryListAdapter extends BaseCheckinAdapter
implements ObservableAdapter {
private LayoutInflater mInflater;
private RemoteResourceManager mRrm;
private Handler mHandler;
private RemoteResourceManagerObserver mResourcesObserver;
public HistoryListAdapter(Context context, RemoteResourceManager rrm) {
super(context);
mInflater = LayoutInflater.from(context);
mHandler = new Handler();
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mRrm.addObserver(mResourcesObserver);
}
public void removeObserver() {
mRrm.deleteObserver(mResourcesObserver);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
final ViewHolder holder;
if (convertView == null) {
convertView = mInflater.inflate(R.layout.history_list_item, null);
holder = new ViewHolder();
holder.icon = (ImageView) convertView.findViewById(R.id.icon);
holder.firstLine = (TextView) convertView.findViewById(R.id.firstLine);
holder.shoutTextView = (TextView) convertView.findViewById(R.id.shoutTextView);
holder.timeTextView = (TextView) convertView.findViewById(R.id.timeTextView);
convertView.setTag(holder);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder) convertView.getTag();
}
Checkin checkin = (Checkin) getItem(position);
if (checkin.getVenue() != null) {
holder.firstLine.setText(checkin.getVenue().getName());
holder.firstLine.setVisibility(View.VISIBLE);
Category category = checkin.getVenue().getCategory();
if (category != null) {
Uri photoUri = Uri.parse(category.getIconUrl());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.icon.setImageBitmap(bitmap);
} catch (IOException e) {
holder.icon.setImageResource(R.drawable.category_none);
}
} else {
holder.icon.setImageResource(R.drawable.category_none);
}
} else {
// This is going to be a shout then.
holder.icon.setImageResource(R.drawable.ic_menu_shout);
holder.firstLine.setVisibility(View.GONE);
}
if (TextUtils.isEmpty(checkin.getShout()) == false) {
holder.shoutTextView.setText(checkin.getShout());
holder.shoutTextView.setVisibility(View.VISIBLE);
} else {
holder.shoutTextView.setVisibility(View.GONE);
}
holder.timeTextView.setText(
StringFormatters.getRelativeTimeSpanString(checkin.getCreated()));
return convertView;
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
mHandler.post(new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
});
}
}
private static class ViewHolder {
ImageView icon;
TextView firstLine;
TextView shoutTextView;
TextView timeTextView;
}
}
| Java |
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.types.Badge;
import android.content.Context;
/**
* @author Joe LaPenna (joe@joelapenna.com)
*/
abstract public class BaseBadgeAdapter extends BaseGroupAdapter<Badge> {
public BaseBadgeAdapter(Context context) {
super(context);
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
/**
* Interface that our adapters can implement to release any observers they
* may have registered with remote resources manager. Most of the adapters
* register an observer in their constructor, but there is was no appropriate
* place to release them. Parent activities can call this method in their
* onPause(isFinishing()) block to properly release the observers.
*
* If the observers are not released, it will cause a memory leak.
*
* @date March 8, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public interface ObservableAdapter {
public void removeObserver();
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.AddressBookEmailBuilder.ContactSimple;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.View.OnClickListener;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.TextView;
import java.util.ArrayList;
import java.util.List;
/**
* @date April 26, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public class FriendSearchInviteNonFoursquareUserAdapter extends BaseAdapter
implements ObservableAdapter {
private LayoutInflater mInflater;
private int mLayoutToInflate;
private AdapterListener mAdapterListener;
private List<ContactSimple> mEmailsAndNames;
public FriendSearchInviteNonFoursquareUserAdapter(
Context context,
AdapterListener adapterListener) {
super();
mInflater = LayoutInflater.from(context);
mLayoutToInflate = R.layout.add_friends_invite_non_foursquare_user_list_item;
mAdapterListener = adapterListener;
mEmailsAndNames = new ArrayList<ContactSimple>();
}
public void removeObserver() {
}
public FriendSearchInviteNonFoursquareUserAdapter(Context context, int layoutResource) {
super();
mInflater = LayoutInflater.from(context);
mLayoutToInflate = layoutResource;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (position == 0) {
ViewHolderInviteAll holder;
if (convertView == null) {
convertView = mInflater.inflate(R.layout.add_friends_invite_non_foursquare_all_list_item, null);
holder = new ViewHolderInviteAll();
holder.addAll = (Button) convertView.findViewById(R.id.addFriendNonFoursquareAllListItemBtn);
convertView.setTag(holder);
} else {
holder = (ViewHolderInviteAll) convertView.getTag();
}
holder.addAll.setOnClickListener(mOnClickListenerInviteAll);
}
else {
ViewHolder holder;
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
holder.name = (TextView) convertView.findViewById(R.id.addFriendNonFoursquareUserListItemName);
holder.email = (TextView) convertView.findViewById(R.id.addFriendNonFoursquareUserListItemEmail);
holder.add = (Button) convertView.findViewById(R.id.addFriendNonFoursquareUserListItemBtn);
convertView.setTag(holder);
holder.add.setOnClickListener(mOnClickListenerInvite);
} else {
holder = (ViewHolder) convertView.getTag();
}
holder.name.setText(mEmailsAndNames.get(position - 1).mName);
holder.email.setText(mEmailsAndNames.get(position - 1).mEmail);
holder.add.setTag(new Integer(position));
}
return convertView;
}
private OnClickListener mOnClickListenerInvite = new OnClickListener() {
@Override
public void onClick(View v) {
Integer position = (Integer) v.getTag();
mAdapterListener.onBtnClickInvite((ContactSimple) getItem(position));
}
};
private OnClickListener mOnClickListenerInviteAll = new OnClickListener() {
@Override
public void onClick(View v) {
mAdapterListener.onInviteAll();
}
};
public void removeItem(int position) throws IndexOutOfBoundsException {
mEmailsAndNames.remove(position);
notifyDataSetInvalidated();
}
public void setContacts(List<ContactSimple> contacts) {
mEmailsAndNames = contacts;
}
static class ViewHolder {
TextView name;
TextView email;
Button add;
}
static class ViewHolderInviteAll {
Button addAll;
}
public interface AdapterListener {
public void onBtnClickInvite(ContactSimple contact);
public void onInfoAreaClick(ContactSimple contact);
public void onInviteAll();
}
@Override
public int getCount() {
if (mEmailsAndNames.size() > 0) {
return mEmailsAndNames.size() + 1;
}
return 0;
}
@Override
public Object getItem(int position) {
if (position == 0) {
return "";
}
return mEmailsAndNames.get(position - 1);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public int getViewTypeCount() {
return 2;
}
@Override
public int getItemViewType(int position) {
if (position == 0) {
return 0;
}
return 1;
}
}
| Java |
/**
* Copyright 2010 Mark Wyszomierski
*/
package com.joelapenna.foursquared.widget;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.types.User;
import com.joelapenna.foursquared.R;
import com.joelapenna.foursquared.util.RemoteResourceManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import java.io.IOException;
import java.util.HashSet;
import java.util.Observable;
import java.util.Observer;
import java.util.Set;
/**
* @date March 8, 2010
* @author Mark Wyszomierski (markww@gmail.com), foursquare.
*/
public class FriendListAdapter extends BaseGroupAdapter<User>
implements ObservableAdapter {
private LayoutInflater mInflater;
private int mLayoutToInflate;
private RemoteResourceManager mRrm;
private RemoteResourceManagerObserver mResourcesObserver;
private Handler mHandler = new Handler();
private Set<String> mLaunchedPhotoFetches;
public FriendListAdapter(Context context, RemoteResourceManager rrm) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = R.layout.friend_list_item;
mRrm = rrm;
mResourcesObserver = new RemoteResourceManagerObserver();
mLaunchedPhotoFetches = new HashSet<String>();
mRrm.addObserver(mResourcesObserver);
}
public void removeObserver() {
mHandler.removeCallbacks(mUpdatePhoto);
mRrm.deleteObserver(mResourcesObserver);
}
public FriendListAdapter(Context context, int layoutResource) {
super(context);
mInflater = LayoutInflater.from(context);
mLayoutToInflate = layoutResource;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// A ViewHolder keeps references to children views to avoid unnecessary
// calls to findViewById() on each row.
ViewHolder holder;
// When convertView is not null, we can reuse it directly, there is no
// need to re-inflate it. We only inflate a new View when the
// convertView supplied by ListView is null.
if (convertView == null) {
convertView = mInflater.inflate(mLayoutToInflate, null);
// Creates a ViewHolder and store references to the two children
// views we want to bind data to.
holder = new ViewHolder();
holder.photo = (ImageView) convertView.findViewById(R.id.friendListItemPhoto);
holder.name = (TextView) convertView.findViewById(R.id.friendListItemName);
convertView.setTag(holder);
} else {
// Get the ViewHolder back to get fast access to the TextView
// and the ImageView.
holder = (ViewHolder) convertView.getTag();
}
User user = (User) getItem(position);
Uri photoUri = Uri.parse(user.getPhoto());
try {
Bitmap bitmap = BitmapFactory.decodeStream(mRrm.getInputStream(photoUri));
holder.photo.setImageBitmap(bitmap);
} catch (IOException e) {
if (Foursquare.MALE.equals(user.getGender())) {
holder.photo.setImageResource(R.drawable.blank_boy);
} else {
holder.photo.setImageResource(R.drawable.blank_girl);
}
if (!mLaunchedPhotoFetches.contains(user.getId())) {
mLaunchedPhotoFetches.add(user.getId());
mRrm.request(photoUri);
}
}
holder.name.setText(user.getFirstname() + " "
+ (user.getLastname() != null ? user.getLastname() : ""));
return convertView;
}
public void removeItem(int position) throws IndexOutOfBoundsException {
group.remove(position);
notifyDataSetInvalidated();
}
private class RemoteResourceManagerObserver implements Observer {
@Override
public void update(Observable observable, Object data) {
mHandler.post(mUpdatePhoto);
}
}
private Runnable mUpdatePhoto = new Runnable() {
@Override
public void run() {
notifyDataSetChanged();
}
};
static class ViewHolder {
ImageView photo;
TextView name;
}
}
| Java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.