コード例 #1
0
/**
 * This is an example of implementing an application service that will run in response to an alarm,
 * allowing us to move long duration work out of an intent receiver.
 *
 * @see AlarmService
 * @see AlarmService_Alarm
 */
public class EnvelopeService extends Service {
  NotificationManager mNM;
  private RedditSettings mSettings = new RedditSettings();
  private HttpClient mClient = Common.getGzipHttpClient();

  @Override
  public void onCreate() {
    mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    mSettings.loadRedditPreferences(this, mClient);
    new PeekEnvelopeServiceTask(this, mClient, mSettings.getMailNotificationStyle()).execute();
  }

  private class PeekEnvelopeServiceTask extends PeekEnvelopeTask {
    public PeekEnvelopeServiceTask(
        Context context, HttpClient client, String mailNotificationStyle) {
      super(context, client, mailNotificationStyle);
    }

    @Override
    public void onPostExecute(Object count) {
      super.onPostExecute(count);
      EnvelopeService.this.stopSelf();
    }
  }

  @Override
  public IBinder onBind(Intent intent) {
    return mBinder;
  }

  /**
   * This is the object that receives interactions from clients. See RemoteService for a more
   * complete example.
   */
  private final IBinder mBinder =
      new Binder() {
        @Override
        protected boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
          return super.onTransact(code, data, reply, flags);
        }
      };

  public static void resetAlarm(Context context, long interval) {
    // Create an IntentSender that will launch our service, to be scheduled
    // with the alarm manager.
    PendingIntent alarmSender =
        PendingIntent.getService(context, 0, new Intent(context, EnvelopeService.class), 0);
    AlarmManager am = (AlarmManager) context.getSystemService(ALARM_SERVICE);
    am.cancel(alarmSender);
    if (interval != 0)
      am.setRepeating(
          AlarmManager.ELAPSED_REALTIME_WAKEUP,
          SystemClock.elapsedRealtime(),
          interval,
          alarmSender);
  }
}
コード例 #2
0
public final class PickSubredditActivity extends ListActivity {

  private static final String TAG = "PickSubredditActivity";

  // Group 1: inner
  private final Pattern MY_SUBREDDITS_OUTER =
      Pattern.compile("your front page reddits.*?<ul>(.*?)</ul>", Pattern.CASE_INSENSITIVE);
  // Group 3: subreddit name. Repeat the matcher.find() until it fails.
  private final Pattern MY_SUBREDDITS_INNER = Pattern.compile("<a(.*?)/r/(.*?)>(.+?)</a>");

  private RedditSettings mSettings = new RedditSettings();
  private HttpClient mClient = Common.getGzipHttpClient();

  private PickSubredditAdapter mSubredditsAdapter;
  private ArrayList<String> mSubredditsList;
  private static final Object ADAPTER_LOCK = new Object();
  private EditText mEt;

  private AsyncTask<?, ?, ?> mCurrentTask = null;
  private final Object mCurrentTaskLock = new Object();

  public static final String[] DEFAULT_SUBREDDITS = {
    "reddit.com",
    "pics",
    "politics",
    "wtf",
    "funny",
    "technology",
    "askreddit",
    "science",
    "programming",
    "gaming",
    "worldnews",
    "comics",
    "offbeat",
    "videos",
    "environment",
    "iama",
    "business",
    "entertainment",
    "bestof",
    "economics",
    "marijuana",
    "todayilearned",
    "linux",
    "android"
  };

  // A list of special subreddits that can be viewed, but cannot be used for submissions. They
  // inherit from the FakeSubreddit class
  // in the redditdev source, so we use the same naming here. Note: Should we add r/Random and
  // r/Friends?
  public static final String[] FAKE_SUBREDDITS = {Constants.FRONTPAGE_STRING, "all"};

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    CookieSyncManager.createInstance(getApplicationContext());

    mSettings.loadRedditPreferences(this, mClient);
    setRequestedOrientation(mSettings.getRotation());
    requestWindowFeature(Window.FEATURE_PROGRESS);
    requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);

    resetUI(null);

    mSubredditsList = cacheSubredditsList(mSubredditsList);

    if (CollectionUtils.isEmpty(mSubredditsList)) restoreLastNonConfigurationInstance();

    if (CollectionUtils.isEmpty(mSubredditsList)) {
      new DownloadRedditsTask().execute();
    } else {
      addFakeSubredditsUnlessSuppressed();
      resetUI(new PickSubredditAdapter(this, mSubredditsList));
    }
  }

  @Override
  public void onResume() {
    super.onResume();
    CookieSyncManager.getInstance().startSync();
  }

  @Override
  public void onPause() {
    super.onPause();
    CookieSyncManager.getInstance().stopSync();
  }

  @Override
  public Object onRetainNonConfigurationInstance() {
    // Avoid having to re-download and re-parse the subreddits list
    // when rotating or opening keyboard.
    return mSubredditsList;
  }

  @SuppressWarnings("unchecked")
  private void restoreLastNonConfigurationInstance() {
    mSubredditsList = (ArrayList<String>) getLastNonConfigurationInstance();
  }

  void resetUI(PickSubredditAdapter adapter) {
    setTheme(mSettings.getTheme());
    setContentView(R.layout.pick_subreddit_view);
    registerForContextMenu(getListView());

    synchronized (ADAPTER_LOCK) {
      if (adapter == null) {
        // Reset the list to be empty.
        mSubredditsList = new ArrayList<String>();
        mSubredditsAdapter = new PickSubredditAdapter(this, mSubredditsList);
      } else {
        mSubredditsAdapter = adapter;
      }
      setListAdapter(mSubredditsAdapter);
      mSubredditsAdapter.mLoading = false;
      mSubredditsAdapter.notifyDataSetChanged(); // Just in case
    }
    Common.updateListDrawables(this, mSettings.getTheme());

    // Set the EditText to do same thing as onListItemClick
    mEt = (EditText) findViewById(R.id.pick_subreddit_input);
    if (mEt != null) {
      mEt.setOnKeyListener(
          new OnKeyListener() {
            public boolean onKey(View v, int keyCode, KeyEvent event) {
              if ((event.getAction() == KeyEvent.ACTION_DOWN)
                  && (keyCode == KeyEvent.KEYCODE_ENTER)) {
                returnSubreddit(mEt.getText().toString().trim());
                return true;
              }
              return false;
            }
          });
      mEt.setFocusableInTouchMode(true);
    }
    Button goButton = (Button) findViewById(R.id.pick_subreddit_button);
    if (goButton != null) {
      goButton.setOnClickListener(
          new OnClickListener() {
            public void onClick(View v) {
              returnSubreddit(mEt.getText().toString().trim());
            }
          });
    }

    getListView().requestFocus();
  }

  @Override
  protected void onListItemClick(ListView l, View v, int position, long id) {
    String item = mSubredditsAdapter.getItem(position);
    returnSubreddit(item);
  }

  private void returnSubreddit(String subreddit) {
    Intent intent = new Intent();
    intent.setData(Util.createSubredditUri(subreddit));
    setResult(RESULT_OK, intent);
    finish();
  }

  private void enableLoadingScreen() {
    if (Util.isLightTheme(mSettings.getTheme())) {
      setContentView(R.layout.loading_light);
    } else {
      setContentView(R.layout.loading_dark);
    }
    synchronized (ADAPTER_LOCK) {
      if (mSubredditsAdapter != null) mSubredditsAdapter.mLoading = true;
    }
    getWindow().setFeatureInt(Window.FEATURE_PROGRESS, 0);
  }

  private void disableLoadingScreen() {
    resetUI(mSubredditsAdapter);
    getWindow().setFeatureInt(Window.FEATURE_PROGRESS, 10000);
  }

  class DownloadRedditsTask extends AsyncTask<Void, Void, ArrayList<String>> {
    @Override
    public ArrayList<String> doInBackground(Void... voidz) {
      ArrayList<String> reddits = null;
      HttpEntity entity = null;
      try {

        reddits = cacheSubredditsList(reddits);

        if (reddits == null) {
          reddits = new ArrayList<String>();

          HttpGet request = new HttpGet(Constants.REDDIT_BASE_URL + "/reddits");
          // Set timeout to 15 seconds
          HttpParams params = request.getParams();
          HttpConnectionParams.setConnectionTimeout(params, 15000);
          HttpConnectionParams.setSoTimeout(params, 15000);

          HttpResponse response = mClient.execute(request);
          entity = response.getEntity();
          BufferedReader in = new BufferedReader(new InputStreamReader(entity.getContent()));

          String line = in.readLine();
          in.close();
          entity.consumeContent();

          Matcher outer = MY_SUBREDDITS_OUTER.matcher(line);
          if (outer.find()) {
            Matcher inner = MY_SUBREDDITS_INNER.matcher(outer.group(1));
            while (inner.find()) {
              reddits.add(inner.group(3));
            }
          } else {
            return null;
          }

          if (Constants.LOGGING) Log.d(TAG, "new subreddit list size: " + reddits.size());

          if (Constants.USE_SUBREDDITS_CACHE) {
            try {
              CacheInfo.setCachedSubredditList(getApplicationContext(), reddits);
              if (Constants.LOGGING) Log.d(TAG, "wrote subreddit list to cache:" + reddits);
            } catch (IOException e) {
              if (Constants.LOGGING) Log.e(TAG, "error on setCachedSubredditList", e);
            }
          }
        }

        return reddits;

      } catch (Exception e) {
        if (Constants.LOGGING) Log.e(TAG, "failed", e);
        if (entity != null) {
          try {
            entity.consumeContent();
          } catch (Exception e2) {
            // Ignore.
          }
        }
      }
      return null;
    }

    @Override
    public void onPreExecute() {
      synchronized (mCurrentTaskLock) {
        if (mCurrentTask != null) {
          this.cancel(true);
          return;
        }
        mCurrentTask = this;
      }
      resetUI(null);
      enableLoadingScreen();
    }

    @Override
    public void onPostExecute(ArrayList<String> reddits) {
      synchronized (mCurrentTaskLock) {
        mCurrentTask = null;
      }
      disableLoadingScreen();

      if (reddits == null || reddits.size() == 0) {
        // Need to make a copy because Arrays.asList returns List backed by original array
        mSubredditsList = new ArrayList<String>();
        mSubredditsList.addAll(Arrays.asList(DEFAULT_SUBREDDITS));
      } else {
        mSubredditsList = reddits;
      }
      addFakeSubredditsUnlessSuppressed();
      resetUI(new PickSubredditAdapter(PickSubredditActivity.this, mSubredditsList));
    }
  }

  private void addFakeSubredditsUnlessSuppressed() {
    // Insert special reddits (front page, all) into subreddits list, unless suppressed by Intent
    // extras
    Bundle extras = getIntent().getExtras();
    boolean addFakeSubreddits = false;
    if (extras != null) {
      boolean shouldHideFakeSubreddits =
          extras.getBoolean(Constants.EXTRA_HIDE_FAKE_SUBREDDITS_STRING, false);
      if (!shouldHideFakeSubreddits) {
        addFakeSubreddits = true;
      }
    } else {
      addFakeSubreddits = true;
    }
    if (addFakeSubreddits) {
      mSubredditsList.addAll(0, Arrays.asList(FAKE_SUBREDDITS));
    }
  }

  private final class PickSubredditAdapter extends ArrayAdapter<String> {
    private LayoutInflater mInflater;
    private boolean mLoading = true;
    private int mFrequentSeparatorPos = ListView.INVALID_POSITION;

    public PickSubredditAdapter(Context context, List<String> objects) {
      super(context, 0, objects);

      mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    }

    @Override
    public boolean isEmpty() {
      if (mLoading) {
        // We don't want the empty state to show when loading.
        return false;
      } else {
        return super.isEmpty();
      }
    }

    @Override
    public int getItemViewType(int position) {
      if (position == mFrequentSeparatorPos) {
        // We don't want the separator view to be recycled.
        return IGNORE_ITEM_VIEW_TYPE;
      }
      return super.getItemViewType(position);
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
      View view;

      // Here view may be passed in for re-use, or we make a new one.
      if (convertView == null) {
        view = mInflater.inflate(android.R.layout.simple_list_item_1, null);
      } else {
        view = convertView;
      }

      TextView text = (TextView) view.findViewById(android.R.id.text1);
      text.setText(mSubredditsAdapter.getItem(position));

      return view;
    }
  }

  protected Dialog onCreateDialog(int id) {
    Dialog dialog;
    ProgressDialog pdialog;

    switch (id) {
        // "Please wait"
      case Constants.DIALOG_LOADING_REDDITS_LIST:
        pdialog = new ProgressDialog(this);
        pdialog.setMessage("Loading your reddits...");
        pdialog.setIndeterminate(true);
        pdialog.setCancelable(false);
        dialog = pdialog;
        break;
      default:
        throw new IllegalArgumentException("Unexpected dialog id " + id);
    }
    return dialog;
  }

  @Override
  protected void onRestoreInstanceState(Bundle state) {
    super.onRestoreInstanceState(state);
    final int[] myDialogs = {
      Constants.DIALOG_LOADING_REDDITS_LIST,
    };
    for (int dialog : myDialogs) {
      try {
        dismissDialog(dialog);
      } catch (IllegalArgumentException e) {
        // Ignore.
      }
    }
  }

  protected ArrayList<String> cacheSubredditsList(ArrayList<String> reddits) {
    if (Constants.USE_SUBREDDITS_CACHE) {
      if (CacheInfo.checkFreshSubredditListCache(getApplicationContext())) {
        reddits = CacheInfo.getCachedSubredditList(getApplicationContext());
        if (Constants.LOGGING) Log.d(TAG, "cached subreddit list:" + reddits);
      }
    }
    return reddits;
  }
}