title: How to get the package name of an application and then launch that app using Intent?
body: <p>I am developing an Android app. In that app, there is a button to go to another activity which contains a list of installed apps on the phone. When the user selects an app, its package name is saved and the user returns to the previous activity. But, how can I get the package name?</p>
  
  <pre><code>public class LoaderCustomSupport extends SherlockFragmentActivity {
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
  
          FragmentManager fm = getSupportFragmentManager();
  
          // Create the list fragment and add it as our sole content.
          if (fm.findFragmentById(android.R.id.content) == null) {
              AppListFragment list = new AppListFragment();
              fm.beginTransaction().add(android.R.id.content, list).commit();
          }
      }
  
      /**
       * This class holds the per-item data in our Loader.
       */
      public static class AppEntry {
          public AppEntry(AppListLoader loader, ApplicationInfo info) {
              mLoader = loader;
              mInfo = info;
              mApkFile = new File(info.sourceDir);
          }
  
          public ApplicationInfo getApplicationInfo() {
              return mInfo;
          }
  
          public String getLabel() {
              return mLabel;
          }
  
          public Drawable getIcon() {
              if (mIcon == null) {
                  if (mApkFile.exists()) {
                      mIcon = mInfo.loadIcon(mLoader.mPm);
                      return mIcon;
                  } else {
                      mMounted = false;
                  }
              } else if (!mMounted) {
                  // If the app wasn't mounted but is now mounted, reload
                  // its icon.
                  if (mApkFile.exists()) {
                      mMounted = true;
                      mIcon = mInfo.loadIcon(mLoader.mPm);
                      return mIcon;
                  }
              } else {
                  return mIcon;
              }
  
              return mLoader.getContext().getResources().getDrawable(
                  android.R.drawable.sym_def_app_icon);
          }
  
          @Override
          public String toString() {
              return mLabel;
          }
  
          void loadLabel(Context context) {
              if (mLabel == null || !mMounted) {
                  if (!mApkFile.exists()) {
                      mMounted = false;
                      mLabel = mInfo.packageName;
                  } else {
                      mMounted = true;
                      CharSequence label = mInfo.loadLabel(context.getPackageManager());
                      mLabel = label != null ? label.toString() : mInfo.packageName;
                  }
              }
          }
  
          private final AppListLoader mLoader;
          private final ApplicationInfo mInfo;
          private final File mApkFile;
          private String mLabel;
          private Drawable mIcon;
          private boolean mMounted;
      }
  
      /**
       * Perform alphabetical comparison of application entry objects.
       */
      public static final Comparator&lt;AppEntry&gt; ALPHA_COMPARATOR = new Comparator&lt;AppEntry&gt;() {
          private final Collator sCollator = Collator.getInstance();
  
          @Override
          public int compare(AppEntry object1, AppEntry object2) {
              return sCollator.compare(object1.getLabel(), object2.getLabel());
          }
      };
  
      /**
       * Helper for determining if the configuration has changed in an interesting
       * way so we need to rebuild the app list.
       */
      public static class InterestingConfigChanges {
          final Configuration mLastConfiguration = new Configuration();
          int mLastDensity;
  
          boolean applyNewConfig(Resources res) {
              int configChanges = mLastConfiguration.updateFrom(res.getConfiguration());
              boolean densityChanged = mLastDensity != res.getDisplayMetrics().densityDpi;
              if (densityChanged || (configChanges&amp;(ActivityInfo.CONFIG_LOCALE
                      |ActivityInfoCompat.CONFIG_UI_MODE|ActivityInfo.CONFIG_SCREEN_LAYOUT)) != 0) {
                  mLastDensity = res.getDisplayMetrics().densityDpi;
                  return true;
              }
              return false;
          }
      }
  
      /**
       * Helper class to look for interesting changes to the installed apps
       * so that the loader can be updated.
       */
      public static class PackageIntentReceiver extends BroadcastReceiver {
          final AppListLoader mLoader;
  
          public PackageIntentReceiver(AppListLoader loader) {
              mLoader = loader;
              IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
              filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
              filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
              filter.addDataScheme("package");
              mLoader.getContext().registerReceiver(this, filter);
              // Register for events related to sdcard installation.
              IntentFilter sdFilter = new IntentFilter();
              sdFilter.addAction(IntentCompat.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);
              sdFilter.addAction(IntentCompat.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
              mLoader.getContext().registerReceiver(this, sdFilter);
          }
  
          @Override
          public void onReceive(Context context, Intent intent) {
              // Tell the loader about the change.
              mLoader.onContentChanged();
          }
      }
  
      /**
       * A custom Loader that loads all of the installed applications.
       */
      public static class AppListLoader extends AsyncTaskLoader&lt;List&lt;AppEntry&gt;&gt; {
          final InterestingConfigChanges mLastConfig = new InterestingConfigChanges();
          final PackageManager mPm;
  
          List&lt;AppEntry&gt; mApps;
          PackageIntentReceiver mPackageObserver;
  
          public AppListLoader(Context context) {
              super(context);
  
              // Retrieve the package manager for later use; note we don't
              // use 'context' directly but instead the save global application
              // context returned by getContext().
              mPm = getContext().getPackageManager();
          }
  
          /**
           * This is where the bulk of our work is done.  This function is
           * called in a background thread and should generate a new set of
           * data to be published by the loader.
           */
          @Override
          public List&lt;AppEntry&gt; loadInBackground() {
              // Retrieve all known applications.
              List&lt;ApplicationInfo&gt; apps = mPm.getInstalledApplications(
                  PackageManager.GET_UNINSTALLED_PACKAGES |
                  PackageManager.GET_DISABLED_COMPONENTS);
              if (apps == null) {
                  apps = new ArrayList&lt;ApplicationInfo&gt;();
              }
  
              final Context context = getContext();
  
              // Create corresponding array of entries and load their labels.
              List&lt;AppEntry&gt; entries = new ArrayList&lt;AppEntry&gt;(apps.size());
              for (int i=0; i&lt;apps.size(); i++) {
                  AppEntry entry = new AppEntry(this, apps.get(i));
                  entry.loadLabel(context);
                  entries.add(entry);
              }
  
              // Sort the list.
              Collections.sort(entries, ALPHA_COMPARATOR);
  
              // Done!
              return entries;
          }
  
          /**
           * Called when there is new data to deliver to the client.  The
           * super class will take care of delivering it; the implementation
           * here just adds a little more logic.
           */
          @Override
          public void deliverResult(List&lt;AppEntry&gt; apps) {
              if (isReset()) {
                  // An async query came in while the loader is stopped.  We
                  // don't need the result.
                  if (apps != null) {
                      onReleaseResources(apps);
                  }
              }
              List&lt;AppEntry&gt; oldApps = apps;
              mApps = apps;
  
              if (isStarted()) {
                  // If the Loader is currently started, we can immediately
                  // deliver its results.
                  super.deliverResult(apps);
              }
  
              // At this point we can release the resources associated with
              // 'oldApps' if needed; now that the new result is delivered we
              // know that it is no longer in use.
              if (oldApps != null) {
                  onReleaseResources(oldApps);
              }
          }
  
          /**
           * Handles a request to start the Loader.
           */
          @Override
          protected void onStartLoading() {
              if (mApps != null) {
                  // If we currently have a result available, deliver it
                  // immediately.
                  deliverResult(mApps);
              }
  
              // Start watching for changes in the app data.
              if (mPackageObserver == null) {
                  mPackageObserver = new PackageIntentReceiver(this);
              }
  
              // Has something interesting in the configuration changed since we
              // last built the app list?
              boolean configChange = mLastConfig.applyNewConfig(getContext().getResources());
  
              if (takeContentChanged() || mApps == null || configChange) {
                  // If the data has changed since the last time it was loaded
                  // or is not currently available, start a load.
                  forceLoad();
              }
         }
  
          /**
           * Handles a request to stop the Loader.
           */
          @Override
          protected void onStopLoading() {
              // Attempt to cancel the current load task if possible.
              cancelLoad();
          }
  
          /**
           * Handles a request to cancel a load.
           */
          @Override
          public void onCanceled(List&lt;AppEntry&gt; apps) {
              super.onCanceled(apps);
  
              // At this point we can release the resources associated with 'apps'
              // if needed.
              onReleaseResources(apps);
          }
  
          /**
           * Handles a request to completely reset the Loader.
           */
          @Override
          protected void onReset() {
              super.onReset();
  
              // Ensure the loader is stopped
              onStopLoading();
  
              // At this point we can release the resources associated with 'apps'
              // if needed.
              if (mApps != null) {
                  onReleaseResources(mApps);
                  mApps = null;
              }
  
              // Stop monitoring for changes.
              if (mPackageObserver != null) {
                  getContext().unregisterReceiver(mPackageObserver);
                  mPackageObserver = null;
              }
          }
  
          /**
           * Helper function to take care of releasing resources associated
           * with an actively loaded data set.
           */
          protected void onReleaseResources(List&lt;AppEntry&gt; apps) {
              // For a simple List&lt;&gt; there is nothing to do.  For something
              // like a Cursor, we would close it here.
          }
      }
  
      public static class AppListAdapter extends ArrayAdapter&lt;AppEntry&gt; {
          private final LayoutInflater mInflater;
  
          public AppListAdapter(Context context) {
              super(context, android.R.layout.simple_list_item_2);
              mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
          }
  
          public void setData(List&lt;AppEntry&gt; data) {
              clear();
              if (data != null) {
                  for (AppEntry appEntry : data) {
                      add(appEntry);
                  }
              }
          }
  
          /**
           * Populate new items in the list.
           */
          @Override
          public View getView(int position, View convertView, ViewGroup parent) {
              View view;
  
              if (convertView == null) {
                  view = mInflater.inflate(R.layout.list_item_icon_text, parent, false);
              } else {
                  view = convertView;
              }
  
              AppEntry item = getItem(position);
              ((ImageView)view.findViewById(R.id.icon)).setImageDrawable(item.getIcon());
              ((TextView)view.findViewById(R.id.text)).setText(item.getLabel());
  
              return view;
          }
      }
  
      public static class AppListFragment extends SherlockListFragment
              implements LoaderManager.LoaderCallbacks&lt;List&lt;AppEntry&gt;&gt; {
  
          // This is the Adapter being used to display the list's data.
          AppListAdapter mAdapter;
  
          // If non-null, this is the current filter the user has provided.
          String mCurFilter;
  
          OnQueryTextListenerCompat mOnQueryTextListenerCompat;
  
          @Override
          public void onActivityCreated(Bundle savedInstanceState) {
              super.onActivityCreated(savedInstanceState);
  
              // Give some text to display if there is no data.  In a real
              // application this would come from a resource.
              setEmptyText("No applications");
  
              // We have a menu item to show in action bar.
              setHasOptionsMenu(true);
  
              // Create an empty adapter we will use to display the loaded data.
              mAdapter = new AppListAdapter(getActivity());
              setListAdapter(mAdapter);
  
              // Start out with a progress indicator.
              setListShown(false);
  
              // Prepare the loader.  Either re-connect with an existing one,
              // or start a new one.
              getLoaderManager().initLoader(0, null, this);
          }
  
          @Override
          public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
              // Place an action bar item for searching.
              MenuItem item = menu.add("Search");
              item.setIcon(android.R.drawable.ic_menu_search);
              item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
              View searchView = SearchViewCompat.newSearchView(getActivity());
              if (searchView != null) {
                  SearchViewCompat.setOnQueryTextListener(searchView,
                          new OnQueryTextListenerCompat() {
                      @Override
                      public boolean onQueryTextChange(String newText) {
                          // Called when the action bar search text has changed.  Since this
                          // is a simple array adapter, we can just have it do the filtering.
                          mCurFilter = !TextUtils.isEmpty(newText) ? newText : null;
                          mAdapter.getFilter().filter(mCurFilter);
                          return true;
                      }
                  });
                  item.setActionView(searchView);
              }
          }
  
          @Override
          public void onListItemClick(ListView l, View v, int position, long id) {
              // Insert desired behavior here.
              Log.i("LoaderCustom", "Item clicked: " + id);
             //Here i want to know the package name of the selected app item in the list
          }
  
          @Override
          public Loader&lt;List&lt;AppEntry&gt;&gt; onCreateLoader(int id, Bundle args) {
              // This is called when a new Loader needs to be created.  This
              // sample only has one Loader with no arguments, so it is simple.
              return new AppListLoader(getActivity());
          }
  
          @Override
          public void onLoadFinished(Loader&lt;List&lt;AppEntry&gt;&gt; loader, List&lt;AppEntry&gt; data) {
              // Set the new data in the adapter.
              mAdapter.setData(data);
  
              // The list should now be shown.
              if (isResumed()) {
                  setListShown(true);
              } else {
                  setListShownNoAnimation(true);
              }
          }
  
          @Override
          public void onLoaderReset(Loader&lt;List&lt;AppEntry&gt;&gt; loader) {
              // Clear the data in the adapter.
              mAdapter.setData(null);
          }
      }
  }
  </code></pre>