import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
/**
 * Checks to see if the activity's intent ({@link android.app.Activity#getIntent()}) is
 * an NFC intent that the app recognizes. If it is, then parse the NFC message and set the
 * activity's intent (using {@link Activity#setIntent(android.content.Intent)}) to something
 * the app can recognize (i.e. a normal {@link Intent#ACTION_VIEW} intent).
 */
public static void tryUpdateIntentFromBeam(Activity activity) {
    Intent originalIntent = activity.getIntent();
    if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(originalIntent.getAction())) {
        Parcelable[] rawMsgs = originalIntent.getParcelableArrayExtra(
                NfcAdapter.EXTRA_NDEF_MESSAGES);
        NdefMessage msg = (NdefMessage) rawMsgs[0];
        // Record 0 contains the MIME type, record 1 is the AAR, if present.
        // In iosched, AARs are not present.
        NdefRecord mimeRecord = msg.getRecords()[0];
        if (ScheduleContract.makeContentItemType(
                ScheduleContract.Sessions.CONTENT_TYPE_ID).equals(
                new String(mimeRecord.getType()))) {
            // Re-set the activity's intent to one that represents session details.
            Intent sessionDetailIntent = new Intent(Intent.ACTION_VIEW,
                    Uri.parse(new String(mimeRecord.getPayload())));
            activity.setIntent(sessionDetailIntent);
        }
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
private void buildSpeaker(boolean isInsert, Speaker speaker,
                          ArrayList<ContentProviderOperation> list) {
    Uri allSpeakersUri = ScheduleContractHelper.setUriAsCalledFromSyncAdapter(
            ScheduleContract.Speakers.CONTENT_URI);
    Uri thisSpeakerUri = ScheduleContractHelper.setUriAsCalledFromSyncAdapter(
            ScheduleContract.Speakers.buildSpeakerUri(speaker.id));

    ContentProviderOperation.Builder builder;
    if (isInsert) {
        builder = ContentProviderOperation.newInsert(allSpeakersUri);
    } else {
        builder = ContentProviderOperation.newUpdate(thisSpeakerUri);
    }

    list.add(builder.withValue(ScheduleContract.SyncColumns.UPDATED, System.currentTimeMillis())
            .withValue(ScheduleContract.Speakers.SPEAKER_ID, speaker.id)
            .withValue(ScheduleContract.Speakers.SPEAKER_NAME, speaker.name)
            .withValue(ScheduleContract.Speakers.SPEAKER_ABSTRACT, speaker.bio)
            .withValue(ScheduleContract.Speakers.SPEAKER_COMPANY, speaker.company)
            .withValue(ScheduleContract.Speakers.SPEAKER_IMAGE_URL, speaker.thumbnailUrl)
            .withValue(ScheduleContract.Speakers.SPEAKER_PLUSONE_URL, speaker.plusoneUrl)
            .withValue(ScheduleContract.Speakers.SPEAKER_TWITTER_URL, speaker.twitterUrl)
            .withValue(ScheduleContract.Speakers.SPEAKER_IMPORT_HASHCODE,
                    speaker.getImportHashcode())
            .build());
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
@Override
public boolean readDataFromCursor(Cursor cursor, QueryEnum query) {
    if (!cursor.moveToFirst()) {
        return false;
    }

    if (SessionFeedbackQueryEnum.SESSION == query) {
        mTitleString = cursor.getString(cursor.getColumnIndex(
                ScheduleContract.Sessions.SESSION_TITLE));

        mSpeakersString = cursor.getString(cursor.getColumnIndex(
                ScheduleContract.Sessions.SESSION_SPEAKER_NAMES));

        return true;
    }

    return false;
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
/**
 * Saves the session feedback using the appropriate content provider, and dismisses the
 * feedback notification.
 */
public void saveSessionFeedback(SessionFeedbackData data) {
    if (null == data.comments) {
        data.comments = "";
    }

    String answers = data.sessionId + ", " + data.sessionRating + ", " + data.sessionRelevantAnswer
            + ", " + data.contentAnswer + ", " + data.speakerAnswer + ", " + data.comments;
    LOGD(TAG, answers);

    ContentValues values = new ContentValues();
    values.put(ScheduleContract.Feedback.SESSION_ID, data.sessionId);
    values.put(ScheduleContract.Feedback.UPDATED, System.currentTimeMillis());
    values.put(ScheduleContract.Feedback.SESSION_RATING, data.sessionRating);
    values.put(ScheduleContract.Feedback.ANSWER_RELEVANCE, data.sessionRelevantAnswer);
    values.put(ScheduleContract.Feedback.ANSWER_CONTENT, data.contentAnswer);
    values.put(ScheduleContract.Feedback.ANSWER_SPEAKER, data.speakerAnswer);
    values.put(ScheduleContract.Feedback.COMMENTS, data.comments);

    Uri uri = mContext.getContentResolver()
            .insert(ScheduleContract.Feedback.buildFeedbackUri(data.sessionId), values);
    LOGD(TAG, null == uri ? "No feedback was saved" : uri.toString());
    dismissFeedbackNotification(data.sessionId);
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
private void reloadFragment() {
    // Build the tag URI
    Uri uri = mCurrentUri;

    if (uri == null) {
        uri = ScheduleContract.Sessions.buildCategoryTagFilterUri(
                ScheduleContract.Sessions.CONTENT_URI,
                mTagFilterHolder.toStringArray(),
                mTagFilterHolder.getCategoryCount());
    } else { // build a uri with the specific filters
        uri = ScheduleContract.Sessions.buildCategoryTagFilterUri(uri,
                mTagFilterHolder.toStringArray(),
                mTagFilterHolder.getCategoryCount());
    }
    setActivityTitle();
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);
    intent.putExtra(ExploreSessionsFragment.EXTRA_SHOW_LIVESTREAMED_SESSIONS,
            mTagFilterHolder.isShowLiveStreamedSessions());

    LOGD(TAG, "Reloading fragment with categories " + mTagFilterHolder.getCategoryCount() +
            " uri: " + uri +
            " showLiveStreamedEvents: " + mTagFilterHolder.isShowLiveStreamedSessions());

    mFragment.reloadFromArguments(intentToFragmentArguments(intent));
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args) {
    switch (id) {
        case ExploreSessionsQuery.NORMAL_TOKEN:
            return new CursorLoader(getActivity(),
                    mCurrentUri, ExploreSessionsQuery.NORMAL_PROJECTION,
                    mShowLiveStreamedSessions ?
                            ScheduleContract.Sessions.LIVESTREAM_OR_YOUTUBE_URL_SELECTION : null,
                    null,
                    ScheduleContract.Sessions.SORT_BY_TYPE_THEN_TIME);
        case ExploreSessionsQuery.SEARCH_TOKEN:
            return new CursorLoader(getActivity(),
                    mCurrentUri, ExploreSessionsQuery.SEARCH_PROJECTION,
                    mShowLiveStreamedSessions ?
                            ScheduleContract.Sessions.LIVESTREAM_OR_YOUTUBE_URL_SELECTION : null,
                    null,
                    ScheduleContract.Sessions.SORT_BY_TYPE_THEN_TIME);
        case TAG_METADATA_TOKEN:
            return TagMetadata.createCursorLoader(getActivity());
        default:
            return null;
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
public void reloadFromArguments(Bundle bundle) {
    Uri oldUri = mCurrentUri;
    int oldSessionQueryToken = mSessionQueryToken;
    boolean oldShowLivestreamedSessions = mShowLiveStreamedSessions;
    mCurrentUri = bundle.getParcelable("_uri");

    if (ScheduleContract.Sessions.isSearchUri(mCurrentUri)) {
        mSessionQueryToken = ExploreSessionsQuery.SEARCH_TOKEN;
    } else {
        mSessionQueryToken = ExploreSessionsQuery.NORMAL_TOKEN;
    }
    mShowLiveStreamedSessions = bundle.getBoolean(EXTRA_SHOW_LIVESTREAMED_SESSIONS, false);

    if ((oldUri != null && oldUri.equals(mCurrentUri)) &&
            oldSessionQueryToken == mSessionQueryToken &&
            oldShowLivestreamedSessions == mShowLiveStreamedSessions) {
        mFullReload = false;
        getLoaderManager().initLoader(mSessionQueryToken, null, this);
    } else {
        // We need to re-run the query
        mFullReload = true;
        getLoaderManager().restartLoader(mSessionQueryToken, null, this);
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
@Override
public void handleMessage(Message msg) {
    switch(msg.what) {
        case MESSAGE_QUERY_UPDATE:
            String query = (String) msg.obj;
            ExploreSessionsFragment instance = mFragmentReference.get();
            if (instance != null) {
                instance.reloadFromArguments(BaseActivity.intentToFragmentArguments(
                        new Intent(Intent.ACTION_SEARCH,
                                ScheduleContract.Sessions.buildSearchUri(query))));
            }
            break;
        default:
            break;
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
private void populateSessionFromCursorRow(SessionData session, Cursor cursor) {
    session.updateData(
            cursor.getString(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_TITLE)),
            cursor.getString(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_ABSTRACT)),
            cursor.getString(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_ID)),
            cursor.getString(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_PHOTO_URL)),
            cursor.getString(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_MAIN_TAG)),
            cursor.getLong(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_START)),
            cursor.getLong(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_END)),
            cursor.getString(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_LIVESTREAM_ID)),
            cursor.getString(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_YOUTUBE_URL)),
            cursor.getString(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_TAGS)),
            cursor.getLong(cursor.getColumnIndex(
                    ScheduleContract.Sessions.SESSION_IN_MY_SCHEDULE)) == 1L);
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
public void sessionDetailItemClicked(View viewClicked) {
    LOGD(TAG, "clicked: " + viewClicked + " " +
            ((viewClicked != null) ? viewClicked.getTag() : ""));
    Object tag = null;
    if (viewClicked != null) {
        tag = viewClicked.getTag();
    }
    if (tag instanceof SessionData) {
        SessionData sessionData = (SessionData)viewClicked.getTag();
        if (!TextUtils.isEmpty(sessionData.getSessionId())) {
            Intent intent = new Intent(getApplicationContext(), SessionDetailActivity.class);
            Uri sessionUri = ScheduleContract.Sessions.buildSessionUri(sessionData.getSessionId());
            intent.setData(sessionUri);
            startActivity(intent);
        } else {
            LOGE(TAG, "Theme item clicked but session data was null:" + sessionData);
            Toast.makeText(this, R.string.unknown_error, Toast.LENGTH_LONG).show();
        }
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
public TagMetadata(Cursor cursor) {
    // Not using while(cursor.moveToNext()) because it would lead to issues when writing tests.
    // Either we would mock cursor.moveToNext() to return true and the test would have infinite
    // loop, or we would mock cursor.moveToNext() to return false, and the test would be for an
    // empty cursor.
    int count = cursor.getCount();
    for(int i = 0; i < count; i ++){
        cursor.moveToPosition(i);
        Tag tag = new Tag(cursor.getString(cursor.getColumnIndex(ScheduleContract.Tags.TAG_ID)),
                cursor.getString(cursor.getColumnIndex(ScheduleContract.Tags.TAG_NAME)),
                cursor.getString(cursor.getColumnIndex(ScheduleContract.Tags.TAG_CATEGORY)),
                cursor.getInt(cursor.getColumnIndex(ScheduleContract.Tags.TAG_ORDER_IN_CATEGORY)),
                cursor.getString(cursor.getColumnIndex(ScheduleContract.Tags.TAG_ABSTRACT)),
                cursor.getInt(cursor.getColumnIndex(ScheduleContract.Tags.TAG_COLOR)));
        mTagsById.put(tag.getId(), tag);
        if (!mTagsInCategory.containsKey(tag.getCategory())) {
            mTagsInCategory.put(tag.getCategory(), new ArrayList<Tag>());
        }
        mTagsInCategory.get(tag.getCategory()).add(tag);
    }

    for (ArrayList<Tag> list : mTagsInCategory.values()) {
        Collections.sort(list);
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
private void scheduleAllStarredSessionFeedbacks() {
    final ContentResolver cr = getContentResolver();
    Cursor c = null;
    try {
        c = cr.query(ScheduleContract.Sessions.CONTENT_MY_SCHEDULE_URI,
            new String[]{
                    ScheduleContract.Sessions.SESSION_TITLE,
                    ScheduleContract.Sessions.SESSION_END,
                    ScheduleContract.Sessions.SESSION_IN_MY_SCHEDULE,
            },
            null,
            null,
            null
    );
    if (c == null) {
        return;
    }
    while (c.moveToNext()) {
        final String sessionTitle = c.getString(0);
        final long sessionEnd = c.getLong(1);
        scheduleFeedbackAlarm(sessionEnd, UNDEFINED_ALARM_OFFSET, sessionTitle);
    }
    } finally {
        if (c != null) { try { c.close(); } catch (Exception ignored) { } }
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
@Override
public void onStatusChanged(int which) {
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            String accountName = AccountUtils.getActiveAccountName(BaseActivity.this);
            if (TextUtils.isEmpty(accountName)) {
                onRefreshingStateChanged(false);
                mManualSyncRequest = false;
                return;
            }

            Account account = new Account(accountName, GoogleAuthUtil.GOOGLE_ACCOUNT_TYPE);
            boolean syncActive = ContentResolver.isSyncActive(
                    account, ScheduleContract.CONTENT_AUTHORITY);
            boolean syncPending = ContentResolver.isSyncPending(
                    account, ScheduleContract.CONTENT_AUTHORITY);
            if (!syncActive && !syncPending) {
                mManualSyncRequest = false;
            }
            onRefreshingStateChanged(syncActive || mManualSyncRequest);
        }
    });
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
/**
 * If an activity's intent is for a Google I/O web URL that the app can handle
 * natively, this method translates the intent to the equivalent native intent.
 */
public static void tryTranslateHttpIntent(Activity activity) {
    Intent intent = activity.getIntent();
    if (intent == null) {
        return;
    }

    Uri uri = intent.getData();
    if (uri == null || TextUtils.isEmpty(uri.getPath())) {
        return;
    }

    Uri sessionDetailWebUrlPrefix = Uri.parse(Config.SESSION_DETAIL_WEB_URL_PREFIX);
    String prefixPath = sessionDetailWebUrlPrefix.getPath();
    String path = uri.getPath();

    if (sessionDetailWebUrlPrefix.getScheme().equals(uri.getScheme()) &&
            sessionDetailWebUrlPrefix.getHost().equals(uri.getHost()) &&
            path.startsWith(prefixPath)) {
        String sessionId = path.substring(prefixPath.length());
        activity.setIntent(new Intent(
                Intent.ACTION_VIEW,
                ScheduleContract.Sessions.buildSessionUri(sessionId)));
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
/**
 * Sets this activity's Android Beam message to one representing the given session.
 */
public static void setBeamSessionUri(Activity activity, Uri sessionUri) {
    NfcAdapter nfcAdapter = NfcAdapter.getDefaultAdapter(activity);
    if (nfcAdapter == null) {
        // No NFC :-(
        return;
    }

    nfcAdapter.setNdefPushMessage(new NdefMessage(
            new NdefRecord[]{
                    new NdefRecord(NdefRecord.TNF_MIME_MEDIA,
                            ScheduleContract.makeContentItemType(
                                    ScheduleContract.Sessions.CONTENT_TYPE_ID).getBytes(),
                            new byte[0],
                            sessionUri.toString().getBytes())
            }), activity);
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
/**
 * Returns the User Data that's on the device's local DB.
 */
static public UserData getLocalUserData(Context context) {
    UserData userData = new UserData();

    // Get Starred Sessions.
    userData.setStarredSessionIds(getColumnContentAsArray(context,
            ScheduleContract.MySchedule.CONTENT_URI, ScheduleContract.MySchedule.SESSION_ID));

    // Get Viewed Videos.
    userData.setViewedVideoIds(getColumnContentAsArray(context,
            ScheduleContract.MyViewedVideos.CONTENT_URI,
            ScheduleContract.MyViewedVideos.VIDEO_ID));

    // Get Feedback Submitted Sessions.
    userData.setFeedbackSubmittedSessionIds(getColumnContentAsArray(context,
            ScheduleContract.MyFeedbackSubmitted.CONTENT_URI,
            ScheduleContract.MyFeedbackSubmitted.SESSION_ID));

    return userData;
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
public static void updateSyncInterval(final Context context, final Account account) {
    LOGD(TAG, "Checking sync interval for " + account);
    long recommended = calculateRecommendedSyncInterval(context);
    long current = SettingsUtils.getCurSyncInterval(context);
    LOGD(TAG, "Recommended sync interval " + recommended + ", current " + current);
    if (recommended != current) {
        LOGD(TAG,
                "Setting up sync for account " + account + ", interval " + recommended + "ms");
        ContentResolver.setIsSyncable(account, ScheduleContract.CONTENT_AUTHORITY, 1);
        ContentResolver.setSyncAutomatically(account, ScheduleContract.CONTENT_AUTHORITY, true);
        if (recommended <= 0L) { // Disable periodic sync.
            ContentResolver.removePeriodicSync(account, ScheduleContract.CONTENT_AUTHORITY,
                    new Bundle());
        } else {
            ContentResolver.addPeriodicSync(account, ScheduleContract.CONTENT_AUTHORITY,
                    new Bundle(), recommended / 1000L);
        }
        SettingsUtils.setCurSyncInterval(context, recommended);
    } else {
        LOGD(TAG, "No need to update sync interval.");
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
@Override
public void onReceive(Context context, Intent intent) {
    String accountName = AccountUtils.getActiveAccountName(context);
    if (TextUtils.isEmpty(accountName)) {
        return;
    }
    Account account = AccountUtils.getActiveAccount(context);
    if (account != null) {
        if (intent.getBooleanExtra(EXTRA_USER_DATA_SYNC_ONLY, false) ) {
            // this is a request to sync user data only, so do a manual sync right now
            // with the userDataOnly == true.
            SyncHelper.requestManualSync(account, true);
        } else {
            // this is a request to sync everything
            ContentResolver.requestSync(account, ScheduleContract.CONTENT_AUTHORITY, new Bundle());
        }
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
private void buildSessionSpeakerMapping(Session session,
                                        ArrayList<ContentProviderOperation> list) {
    final Uri uri = ScheduleContractHelper.setUriAsCalledFromSyncAdapter(
            ScheduleContract.Sessions.buildSpeakersDirUri(session.id));

    // delete any existing relationship between this session and speakers
    list.add(ContentProviderOperation.newDelete(uri).build());

    // add relationship records to indicate the speakers for this session
    if (session.speakers != null) {
        for (String speakerId : session.speakers) {
            list.add(ContentProviderOperation.newInsert(uri)
                    .withValue(ScheduleDatabase.SessionsSpeakers.SESSION_ID, session.id)
                    .withValue(ScheduleDatabase.SessionsSpeakers.SPEAKER_ID, speakerId)
                    .build());
        }
    }
}
 

import com.google.samples.apps.iosched.provider.ScheduleContract; //导入依赖的package包/类
private void buildMarkers(ArrayList<ContentProviderOperation> list) {
    Uri uri = ScheduleContractHelper
            .setUriAsCalledFromSyncAdapter(ScheduleContract.MapMarkers.CONTENT_URI);

    list.add(ContentProviderOperation.newDelete(uri).build());

    for (String floor : mMarkers.keySet()) {
        for (Marker marker : mMarkers.get(floor)) {
            ContentProviderOperation.Builder builder = ContentProviderOperation.newInsert(uri);
            builder.withValue(ScheduleContract.MapMarkers.MARKER_ID, marker.id);
            builder.withValue(ScheduleContract.MapMarkers.MARKER_FLOOR, floor);
            builder.withValue(ScheduleContract.MapMarkers.MARKER_LABEL, marker.title);
            builder.withValue(ScheduleContract.MapMarkers.MARKER_LATITUDE, marker.lat);
            builder.withValue(ScheduleContract.MapMarkers.MARKER_LONGITUDE, marker.lng);
            builder.withValue(ScheduleContract.MapMarkers.MARKER_TYPE, marker.type);
            list.add(builder.build());
        }
    }
}