Back to project page AndroidTrainingCode.
The source code is released under:
Apache License
If you think the Android project AndroidTrainingCode listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/* * Copyright (C) 2012 The Android Open Source Project *// w ww .ja v a2s .c om * 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.example.android.threadsample; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.os.Build; import android.os.Bundle; import android.support.v4.app.FragmentActivity; import android.support.v4.app.FragmentManager; import android.support.v4.app.FragmentManager.OnBackStackChangedListener; import android.support.v4.app.FragmentTransaction; import android.support.v4.content.LocalBroadcastManager; import android.util.Log; import android.view.View; import android.view.WindowManager; /** * This activity displays Picasa's current featured images. It uses a service running * a background thread to download Picasa's "featured image" RSS feed. * <p> * An IntentHandler is used to communicate between the active Fragment and this * activity. This pattern simulates some of the communication used between * activities, and allows this activity to make choices of how to manage the * fragments. */ public class DisplayActivity extends FragmentActivity implements OnBackStackChangedListener { // A handle to the main screen view View mMainView; // An instance of the status broadcast receiver DownloadStateReceiver mDownloadStateReceiver; // Tracks whether Fragments are displaying side-by-side boolean mSideBySide; // Tracks whether navigation should be hidden boolean mHideNavigation; // Tracks whether the app is in full-screen mode boolean mFullScreen; // Tracks the number of Fragments on the back stack int mPreviousStackCount; // Instantiates a new broadcast receiver for handling Fragment state private FragmentDisplayer mFragmentDisplayer = new FragmentDisplayer(); // Sets a tag to use in logging private static final String CLASS_TAG = "DisplayActivity"; /** * Sets full screen mode on the device, by setting parameters in the current * window and View * @param fullscreen */ public void setFullScreen(boolean fullscreen) { // If full screen is set, sets the fullscreen flag in the Window manager getWindow().setFlags( fullscreen ? WindowManager.LayoutParams.FLAG_FULLSCREEN : 0, WindowManager.LayoutParams.FLAG_FULLSCREEN); // Sets the global fullscreen flag to the current setting mFullScreen = fullscreen; // If the platform version is Android 3.0 (Honeycomb) or above if (Build.VERSION.SDK_INT >= 11) { // Sets the View to be "low profile". Status and navigation bar icons will be dimmed int flag = fullscreen ? View.SYSTEM_UI_FLAG_LOW_PROFILE : 0; // If the platform version is Android 4.0 (ICS) or above if (Build.VERSION.SDK_INT >= 14 && fullscreen) { // Hides all of the navigation icons flag |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION; } // Applies the settings to the screen View mMainView.setSystemUiVisibility(flag); // If the user requests a full-screen view, hides the Action Bar. if ( fullscreen ) { this.getActionBar().hide(); } else { this.getActionBar().show(); } } } /* * A callback invoked when the task's back stack changes. This allows the app to * move to the previous state of the Fragment being displayed. * */ @Override public void onBackStackChanged() { // Gets the previous global stack count int previousStackCount = mPreviousStackCount; // Gets a FragmentManager instance FragmentManager localFragmentManager = getSupportFragmentManager(); // Sets the current back stack count int currentStackCount = localFragmentManager.getBackStackEntryCount(); // Re-sets the global stack count to be the current count mPreviousStackCount = currentStackCount; /* * If the current stack count is less than the previous, something was popped off the stack * probably because the user clicked Back. */ boolean popping = currentStackCount < previousStackCount; Log.d(CLASS_TAG, "backstackchanged: popping = " + popping); // When going backwards in the back stack, turns off full screen mode. if (popping) { setFullScreen(false); } } /* * This callback is invoked by the system when the Activity is being killed * It saves the full screen status, so it can be restored when the Activity is restored * */ @Override protected void onSaveInstanceState(Bundle outState) { outState.putBoolean(Constants.EXTENDED_FULLSCREEN, mFullScreen); super.onSaveInstanceState(outState); } /* * This callback is invoked when the Activity is first created. It sets up the Activity's * window and initializes the Fragments associated with the Activity */ @Override public void onCreate(Bundle stateBundle) { // Sets fullscreen-related flags for the display getWindow().setFlags( WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR, WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR); // Calls the super method (required) super.onCreate(stateBundle); // Inflates the main View, which will be the host View for the fragments mMainView = getLayoutInflater().inflate(R.layout.fragmenthost, null); // Sets the content view for the Activity setContentView(mMainView); /* * Creates an intent filter for DownloadStateReceiver that intercepts broadcast Intents */ // The filter's action is BROADCAST_ACTION IntentFilter statusIntentFilter = new IntentFilter( Constants.BROADCAST_ACTION); // Sets the filter's category to DEFAULT statusIntentFilter.addCategory(Intent.CATEGORY_DEFAULT); // Instantiates a new DownloadStateReceiver mDownloadStateReceiver = new DownloadStateReceiver(); // Registers the DownloadStateReceiver and its intent filters LocalBroadcastManager.getInstance(this).registerReceiver( mDownloadStateReceiver, statusIntentFilter); /* * Creates intent filters for the FragmentDisplayer */ // One filter is for the action ACTION_VIEW_IMAGE IntentFilter displayerIntentFilter = new IntentFilter( Constants.ACTION_VIEW_IMAGE); // Adds a data filter for the HTTP scheme displayerIntentFilter.addDataScheme("http"); // Registers the receiver LocalBroadcastManager.getInstance(this).registerReceiver( mFragmentDisplayer, displayerIntentFilter); // Creates a second filter for ACTION_ZOOM_IMAGE displayerIntentFilter = new IntentFilter(Constants.ACTION_ZOOM_IMAGE); // Registers the receiver LocalBroadcastManager.getInstance(this).registerReceiver( mFragmentDisplayer, displayerIntentFilter); // Gets an instance of the support library FragmentManager FragmentManager localFragmentManager = getSupportFragmentManager(); /* * Detects if side-by-side display should be enabled. It's only available on xlarge and * sw600dp devices (for example, tablets). The setting in res/values/ is "false", but this * is overridden in values-xlarge and values-sw600dp. */ mSideBySide = getResources().getBoolean(R.bool.sideBySide); /* * Detects if hiding navigation controls should be enabled. On xlarge andsw600dp, it should * be false, to avoid having the user enter an additional tap. */ mHideNavigation = getResources().getBoolean(R.bool.hideNavigation); /* * Adds the back stack change listener defined in this Activity as the listener for the * FragmentManager. See the method onBackStackChanged(). */ localFragmentManager.addOnBackStackChangedListener(this); // If the incoming state of the Activity is null, sets the initial view to be thumbnails if (null == stateBundle) { // Starts a Fragment transaction to track the stack FragmentTransaction localFragmentTransaction = localFragmentManager .beginTransaction(); // Adds the PhotoThumbnailFragment to the host View localFragmentTransaction.add(R.id.fragmentHost, new PhotoThumbnailFragment(), Constants.THUMBNAIL_FRAGMENT_TAG); // Commits this transaction to display the Fragment localFragmentTransaction.commit(); // The incoming state of the Activity isn't null. } else { // Gets the previous state of the fullscreen indicator mFullScreen = stateBundle.getBoolean(Constants.EXTENDED_FULLSCREEN); // Sets the fullscreen flag to its previous state setFullScreen(mFullScreen); // Gets the previous backstack entry count. mPreviousStackCount = localFragmentManager.getBackStackEntryCount(); } } /* * This callback is invoked when the system is about to destroy the Activity. */ @Override public void onDestroy() { // If the DownloadStateReceiver still exists, unregister it and set it to null if (mDownloadStateReceiver != null) { LocalBroadcastManager.getInstance(this).unregisterReceiver(mDownloadStateReceiver); mDownloadStateReceiver = null; } // Unregisters the FragmentDisplayer instance LocalBroadcastManager.getInstance(this).unregisterReceiver(this.mFragmentDisplayer); // Sets the main View to null mMainView = null; // Must always call the super method at the end. super.onDestroy(); } /* * This callback is invoked when the system is stopping the Activity. It stops * background threads. */ @Override protected void onStop() { // Cancel all the running threads managed by the PhotoManager PhotoManager.cancelAll(); super.onStop(); } /** * This class uses the BroadcastReceiver framework to detect and handle status messages from * the service that downloads URLs. */ private class DownloadStateReceiver extends BroadcastReceiver { private DownloadStateReceiver() { // prevents instantiation by other packages. } /** * * This method is called by the system when a broadcast Intent is matched by this class' * intent filters * * @param context An Android context * @param intent The incoming broadcast Intent */ @Override public void onReceive(Context context, Intent intent) { /* * Gets the status from the Intent's extended data, and chooses the appropriate action */ switch (intent.getIntExtra(Constants.EXTENDED_DATA_STATUS, Constants.STATE_ACTION_COMPLETE)) { // Logs "started" state case Constants.STATE_ACTION_STARTED: if (Constants.LOGD) { Log.d(CLASS_TAG, "State: STARTED"); } break; // Logs "connecting to network" state case Constants.STATE_ACTION_CONNECTING: if (Constants.LOGD) { Log.d(CLASS_TAG, "State: CONNECTING"); } break; // Logs "parsing the RSS feed" state case Constants.STATE_ACTION_PARSING: if (Constants.LOGD) { Log.d(CLASS_TAG, "State: PARSING"); } break; // Logs "Writing the parsed data to the content provider" state case Constants.STATE_ACTION_WRITING: if (Constants.LOGD) { Log.d(CLASS_TAG, "State: WRITING"); } break; // Starts displaying data when the RSS download is complete case Constants.STATE_ACTION_COMPLETE: // Logs the status if (Constants.LOGD) { Log.d(CLASS_TAG, "State: COMPLETE"); } // Finds the fragment that displays thumbnails PhotoThumbnailFragment localThumbnailFragment = (PhotoThumbnailFragment) getSupportFragmentManager().findFragmentByTag( Constants.THUMBNAIL_FRAGMENT_TAG); // If the thumbnail Fragment is hidden, don't change its display status if ((localThumbnailFragment == null) || (!localThumbnailFragment.isVisible())) return; // Indicates that the thumbnail Fragment is visible localThumbnailFragment.setLoaded(true); break; default: break; } } } /** * This class uses the broadcast receiver framework to detect incoming broadcast Intents * and change the currently-visible fragment based on the Intent action. * It adds or replaces Fragments as necessary, depending on how much screen real-estate is * available. */ private class FragmentDisplayer extends BroadcastReceiver { // Default null constructor public FragmentDisplayer() { // Calls the constructor for BroadcastReceiver super(); } /** * Receives broadcast Intents for viewing or zooming pictures, and displays the * appropriate Fragment. * * @param context The current Context of the callback * @param intent The broadcast Intent that triggered the callback */ @Override public void onReceive(Context context, Intent intent) { // Declares a local FragmentManager instance FragmentManager fragmentManager1; // Declares a local instance of the Fragment that displays photos PhotoFragment photoFragment; // Stores a string representation of the URL in the incoming Intent String urlString; // If the incoming Intent is a request is to view an image if (intent.getAction().equals(Constants.ACTION_VIEW_IMAGE)) { // Gets an instance of the support library fragment manager fragmentManager1 = getSupportFragmentManager(); // Gets a handle to the Fragment that displays photos photoFragment = (PhotoFragment) fragmentManager1.findFragmentByTag( Constants.PHOTO_FRAGMENT_TAG ); // Gets the URL of the picture to display urlString = intent.getDataString(); // If the photo Fragment exists from a previous display if (null != photoFragment) { // If the incoming URL is not already being displayed if (!urlString.equals(photoFragment.getURLString())) { // Sets the Fragment to use the URL from the Intent for the photo photoFragment.setPhoto(urlString); // Loads the photo into the Fragment photoFragment.loadPhoto(); } // If the Fragment doesn't already exist } else { // Instantiates a new Fragment photoFragment = new PhotoFragment(); // Sets the Fragment to use the URL from the Intent for the photo photoFragment.setPhoto(urlString); // Starts a new Fragment transaction FragmentTransaction localFragmentTransaction2 = fragmentManager1.beginTransaction(); // If the fragments are side-by-side, adds the photo Fragment to the display if (mSideBySide) { localFragmentTransaction2.add( R.id.fragmentHost, photoFragment, Constants.PHOTO_FRAGMENT_TAG ); /* * If the Fragments are not side-by-side, replaces the current Fragment with * the photo Fragment */ } else { localFragmentTransaction2.replace( R.id.fragmentHost, photoFragment, Constants.PHOTO_FRAGMENT_TAG); } // Don't remember the transaction (sets the Fragment backstack to null) localFragmentTransaction2.addToBackStack(null); // Commits the transaction localFragmentTransaction2.commit(); } // If not in side-by-side mode, sets "full screen", so that no controls are visible if (!mSideBySide) setFullScreen(true); /* * If the incoming Intent is a request to zoom in on an existing image * (Notice that zooming is only supported on large-screen devices) */ } else if (intent.getAction().equals(Constants.ACTION_ZOOM_IMAGE)) { // If the Fragments are being displayed side-by-side if (mSideBySide) { // Gets another instance of the FragmentManager FragmentManager localFragmentManager2 = getSupportFragmentManager(); // Gets a thumbnail Fragment instance PhotoThumbnailFragment localThumbnailFragment = (PhotoThumbnailFragment) localFragmentManager2.findFragmentByTag( Constants.THUMBNAIL_FRAGMENT_TAG); // If the instance exists from a previous display if (null != localThumbnailFragment) { // if the existing instance is visible if (localThumbnailFragment.isVisible()) { // Starts a fragment transaction FragmentTransaction localFragmentTransaction2 = localFragmentManager2.beginTransaction(); /* * Hides the current thumbnail, clears the backstack, and commits the * transaction */ localFragmentTransaction2.hide(localThumbnailFragment); localFragmentTransaction2.addToBackStack(null); localFragmentTransaction2.commit(); // If the existing instance is not visible, display it by going "Back" } else { // Pops the back stack to show the previous Fragment state localFragmentManager2.popBackStack(); } } // Removes controls from the screen setFullScreen(true); } } } } }