/**
* Create a chooser intent to select the source to get image from.<br>
* The source can be camera's (ACTION_IMAGE_CAPTURE) or gallery's (ACTION_GET_CONTENT).<br>
* All possible sources are added to the intent chooser.
*/
public Intent getPickImageChooserIntent() {
// Determine Uri of camera image to save.
Uri outputFileUri = getCaptureImageOutputUri();
List<Intent> allIntents = new ArrayList<>();
PackageManager packageManager = getActivity().getPackageManager();
// collect all camera intents
Intent captureIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
List<ResolveInfo> listCam = packageManager.queryIntentActivities(captureIntent, 0);
for (ResolveInfo res : listCam) {
Intent intent = new Intent(captureIntent);
intent.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name));
intent.setPackage(res.activityInfo.packageName);
if (outputFileUri != null) {
intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
}
allIntents.add(intent);
}
// collect all gallery intents
Intent galleryIntent = new Intent(Intent.ACTION_GET_CONTENT);
galleryIntent.setType("image/*");
List<ResolveInfo> listGallery = packageManager.queryIntentActivities(galleryIntent, 0);
for (ResolveInfo res : listGallery) {
Intent intent = new Intent(galleryIntent);
intent.setComponent(new ComponentName(res.activityInfo.packageName, res.activityInfo.name));
intent.setPackage(res.activityInfo.packageName);
allIntents.add(intent);
}
// the main intent is the last in the list (f*****g android) so pickup the useless one
Intent mainIntent = allIntents.get(allIntents.size() - 1);
for (Intent intent : allIntents) {
if (intent
.getComponent()
.getClassName()
.equals("com.android.documentsui.DocumentsActivity")) {
mainIntent = intent;
break;
}
}
allIntents.remove(mainIntent);
// Create a chooser from the main intent
Intent chooserIntent = Intent.createChooser(mainIntent, getString(R.string.choose_photos));
// Add all other intents
chooserIntent.putExtra(
Intent.EXTRA_INITIAL_INTENTS, allIntents.toArray(new Parcelable[allIntents.size()]));
return chooserIntent;
}
public boolean showFileChooser(
final String mimeType,
final String chooserTitle,
final boolean allowMultiple,
final boolean mustCanRead) {
if (mimeType == null || choosing) {
return false;
}
choosing = true;
// 檢查是否有可用的Activity
final PackageManager packageManager = activity.getPackageManager();
final Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
intent.setType(mimeType);
List<ResolveInfo> list =
packageManager.queryIntentActivities(intent, PackageManager.GET_ACTIVITIES);
if (list.size() > 0) {
this.mustCanRead = mustCanRead;
// 如果有可用的Activity
Intent picker = new Intent(Intent.ACTION_GET_CONTENT);
picker.setType(mimeType);
picker.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, allowMultiple);
picker.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
// 使用Intent Chooser
Intent destIntent = Intent.createChooser(picker, chooserTitle);
activity.startActivityForResult(destIntent, ACTIVITY_FILE_CHOOSER);
return true;
} else {
return false;
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
final PackageManager pm = getPackageManager();
if (pm == null) {
launchInternalPicker();
return;
}
Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
intent.setType("application/zip");
try {
if (pm.queryIntentActivities(intent, PackageManager.GET_ACTIVITIES).size() > 0) {
intent = new Intent();
intent.setType("application/zip");
intent.setAction(Intent.ACTION_GET_CONTENT);
startActivityForResult(intent, REQUEST_PICK_FILE);
} else {
throw new ActivityNotFoundException();
}
} catch (ActivityNotFoundException e) {
Timber.e(e, "No activity found to handle file picking! Falling back to default!");
launchInternalPicker();
}
}
@Override
public boolean isSpecializedHandlerAvailable(Intent intent) {
try {
PackageManager pm = mActivity.getPackageManager();
List<ResolveInfo> handlers =
pm.queryIntentActivities(intent, PackageManager.GET_RESOLVED_FILTER);
if (handlers == null || handlers.size() == 0) {
return false;
}
for (ResolveInfo resolveInfo : handlers) {
IntentFilter filter = resolveInfo.filter;
if (filter == null) {
// No intent filter matches this intent?
// Error on the side of staying in the browser, ignore
continue;
}
if (filter.countDataAuthorities() == 0 || filter.countDataPaths() == 0) {
// Generic handler, skip
continue;
}
return true;
}
} catch (RuntimeException e) {
logTransactionTooLargeOrRethrow(e, intent);
}
return false;
}
public static String e(Context context) {
if (d == null) {
StringBuilder stringBuilder = new StringBuilder();
PackageManager packageManager = context.getPackageManager();
List queryIntentActivities =
packageManager.queryIntentActivities(
new Intent("android.intent.action.VIEW", Uri.parse("geo:0,0?q=donuts")),
Menu.CATEGORY_CONTAINER);
if (queryIntentActivities == null || queryIntentActivities.isEmpty()) {
stringBuilder.append("m");
}
List queryIntentActivities2 =
packageManager.queryIntentActivities(
new Intent(
"android.intent.action.VIEW", Uri.parse("market://search?q=pname:com.google")),
Menu.CATEGORY_CONTAINER);
if (queryIntentActivities2 == null || queryIntentActivities2.isEmpty()) {
if (stringBuilder.length() > 0) {
stringBuilder.append(",");
}
stringBuilder.append("a");
}
d = stringBuilder.toString();
}
return d;
}
/**
* Builds an entire list (suitable for display) of activities that are searchable, by iterating
* the entire set of ACTION_SEARCH & ACTION_WEB_SEARCH intents.
*
* <p>Also clears the hash of all activities -> searches which will refill as the user clicks
* "search".
*
* <p>This should only be done at startup and again if we know that the list has changed.
*
* <p>TODO: every activity that provides a ACTION_SEARCH intent should also provide searchability
* meta-data. There are a bunch of checks here that, if data is not found, silently skip to the
* next activity. This won't help a developer trying to figure out why their activity isn't
* showing up in the list, but an exception here is too rough. I would like to find a better
* notification mechanism.
*
* <p>TODO: sort the list somehow? UI choice.
*/
public void buildSearchableList() {
// These will become the new values at the end of the method
HashMap<ComponentName, SearchableInfo> newSearchablesMap =
new HashMap<ComponentName, SearchableInfo>();
ArrayList<SearchableInfo> newSearchablesList = new ArrayList<SearchableInfo>();
ArrayList<SearchableInfo> newSearchablesInGlobalSearchList = new ArrayList<SearchableInfo>();
final PackageManager pm = mContext.getPackageManager();
// Use intent resolver to generate list of ACTION_SEARCH & ACTION_WEB_SEARCH receivers.
List<ResolveInfo> searchList;
final Intent intent = new Intent(Intent.ACTION_SEARCH);
searchList = pm.queryIntentActivities(intent, PackageManager.GET_META_DATA);
List<ResolveInfo> webSearchInfoList;
final Intent webSearchIntent = new Intent(Intent.ACTION_WEB_SEARCH);
webSearchInfoList = pm.queryIntentActivities(webSearchIntent, PackageManager.GET_META_DATA);
// analyze each one, generate a Searchables record, and record
if (searchList != null || webSearchInfoList != null) {
int search_count = (searchList == null ? 0 : searchList.size());
int web_search_count = (webSearchInfoList == null ? 0 : webSearchInfoList.size());
int count = search_count + web_search_count;
for (int ii = 0; ii < count; ii++) {
// for each component, try to find metadata
ResolveInfo info =
(ii < search_count) ? searchList.get(ii) : webSearchInfoList.get(ii - search_count);
ActivityInfo ai = info.activityInfo;
// Check first to avoid duplicate entries.
if (newSearchablesMap.get(new ComponentName(ai.packageName, ai.name)) == null) {
SearchableInfo searchable = SearchableInfo.getActivityMetaData(mContext, ai);
if (searchable != null) {
newSearchablesList.add(searchable);
newSearchablesMap.put(searchable.getSearchActivity(), searchable);
if (searchable.shouldIncludeInGlobalSearch()) {
newSearchablesInGlobalSearchList.add(searchable);
}
}
}
}
}
List<ResolveInfo> newGlobalSearchActivities = findGlobalSearchActivities();
// Find the global search activity
ComponentName newGlobalSearchActivity = findGlobalSearchActivity(newGlobalSearchActivities);
// Find the web search activity
ComponentName newWebSearchActivity = findWebSearchActivity(newGlobalSearchActivity);
// Store a consistent set of new values
synchronized (this) {
mSearchablesMap = newSearchablesMap;
mSearchablesList = newSearchablesList;
mSearchablesInGlobalSearchList = newSearchablesInGlobalSearchList;
mGlobalSearchActivities = newGlobalSearchActivities;
mCurrentGlobalSearchActivity = newGlobalSearchActivity;
mWebSearchActivity = newWebSearchActivity;
}
}
public static String getDefaultPkgName(MainAppContext appContext) {
String defaultPkgName = null;
PackageManager pm = appContext.mContainerContext.getPackageManager();
Intent intent = new Intent(MediaStore.INTENT_ACTION_MUSIC_PLAYER);
List<ResolveInfo> resolveInfos =
pm.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
if (resolveInfos != null) {
for (int i = 0; i < resolveInfos.size(); i++) {
if ((resolveInfos.get(i).activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
> 0) {
defaultPkgName = resolveInfos.get(i).activityInfo.packageName;
return defaultPkgName;
}
}
} else {
intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_APP_MUSIC);
resolveInfos = pm.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
for (int i = 0; i < resolveInfos.size(); i++) {
if ((resolveInfos.get(i).activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
> 0) {
defaultPkgName = resolveInfos.get(i).activityInfo.packageName;
return defaultPkgName;
}
}
}
return null;
}
/**
* Indicates whether the specified action can be used as an intent. This method queries the
* package manager for installed packages that can respond to an intent with the specified action.
* If no suitable package is found, this method returns false.
* http://android-developers.blogspot.com/2009/01/can-i-use-this-intent.html
*
* @param context The application's environment.
* @param action The Intent action to check for availability.
* @return True if an Intent with the specified action can be sent and responded to, false
* otherwise.
*/
public static boolean isIntentAvailable(Context context, String action) {
final PackageManager packageManager = context.getPackageManager();
final Intent intent = new Intent(action);
List<ResolveInfo> list =
packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
return list.size() > 0;
}
public static boolean isIntentAvailable(Intent intent) {
final PackageManager packageManager = A.getApp().getPackageManager();
List<ResolveInfo> list =
packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
// Logger.d(TAG, "isIntentAvailable(" + intent + "), res:" + list.size());
return list.size() > 0;
}
public static Map<String, DynActivityPlugin> getDynActivityPlugins(Context ctxt, String action) {
if (!CACHED_ACTIVITY_RESOLUTION.containsKey(action)) {
HashMap<String, DynActivityPlugin> plugins = new HashMap<String, DynActivityPlugin>();
PackageManager packageManager = ctxt.getPackageManager();
Intent it = new Intent(action);
List<ResolveInfo> availables = packageManager.queryIntentActivities(it, 0);
for (ResolveInfo resInfo : availables) {
ActivityInfo actInfos = resInfo.activityInfo;
if (packageManager.checkPermission(SipManager.PERMISSION_USE_SIP, actInfos.packageName)
== PackageManager.PERMISSION_GRANTED) {
ComponentName cmp = new ComponentName(actInfos.packageName, actInfos.name);
DynActivityPlugin dynInfos;
dynInfos =
new DynActivityPlugin(
actInfos.loadLabel(packageManager).toString(), action, cmp, actInfos.metaData);
plugins.put(cmp.flattenToString(), dynInfos);
}
}
CACHED_ACTIVITY_RESOLUTION.put(action, plugins);
}
return CACHED_ACTIVITY_RESOLUTION.get(action);
}
private void runApp(List<MainListItem> items) {
// 起動中のアプリ情報を取得
Intent it = new Intent(Intent.ACTION_MAIN);
it.addCategory(Intent.CATEGORY_LAUNCHER);
List<RunningAppProcessInfo> runningApp = activityManager.getRunningAppProcesses();
List<RunningServiceInfo> runningService = activityManager.getRunningServices(100);
List<ResolveInfo> appList = packageManager.queryIntentActivities(it, 0);
if (runningApp != null) {
for (RunningAppProcessInfo app : runningApp) {
try {
// アプリ名をリストに追加
ApplicationInfo appInfo = packageManager.getApplicationInfo(app.processName, 0);
items.add(
new MainListItem(
packageManager.getApplicationIcon(appInfo),
returnLabel(app.processName),
app.processName,
app.pid,
usageMemory(app.pid),
0,
true,
app.importance,
serviceClassNames(runningService, app),
mainClassName(appList, app)));
} catch (NameNotFoundException e) {
e.printStackTrace();
}
}
}
}
/**
* 获取当前安装的dock风格包基础信息，每次重新扫描，调用者调用完后要对此返回列表清空
*
* @return
*/
public ArrayList<StyleBaseInfo> getAllStyleBaseInfos() {
ArrayList<StyleBaseInfo> mList = new ArrayList<StyleBaseInfo>();
Intent intent = new Intent(ICustomAction.ACTION_PKG_NAME);
intent.addCategory(Intent.CATEGORY_DEFAULT);
PackageManager pm = mContext.getPackageManager();
List<ResolveInfo> styles = pm.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
int size = styles.size();
for (int i = 0; i < size; i++) {
String appPackageName = styles.get(i).activityInfo.packageName;
String appName = (String) pm.getApplicationLabel(styles.get(i).activityInfo.applicationInfo);
if (null != appPackageName && null != appName) {
DockStylePkgInfo info = new DockStylePkgInfo();
info.mPkgName = appPackageName;
info.mStyleName = appName;
mList.add(info);
}
}
styles.clear();
styles = null;
return mList;
}
/**
* Send a URL up to Android to be handled by a browser.
*
* @param link The URL to be opened.
*/
private void execURL(String link) {
Uri webLink = Uri.parse(link);
Intent openLink = new Intent(Intent.ACTION_VIEW, webLink);
PackageManager pm = getPackageManager();
List<ResolveInfo> handlers = pm.queryIntentActivities(openLink, 0);
if (handlers.size() > 0) startActivity(openLink);
}
private void checkAppKeySetup() {
// Check to make sure that we have a valid app key
if (APP_KEY.startsWith("CHANGE") || APP_SECRET.startsWith("CHANGE")) {
showToast(
"You must apply for an app key and secret from developers.dropbox.com, and add them to the DBRoulette ap before trying it.");
finish();
return;
}
// Check if the app has set up its manifest properly.
Intent testIntent = new Intent(Intent.ACTION_VIEW);
String scheme = "db-" + APP_KEY;
String uri = scheme + "://" + AuthActivity.AUTH_VERSION + "/test";
testIntent.setData(Uri.parse(uri));
PackageManager pm = getPackageManager();
if (0 == pm.queryIntentActivities(testIntent, 0).size()) {
showToast(
"URL scheme in your app's "
+ "manifest is not set up correctly. You should have a "
+ "com.dropbox.client2.android.AuthActivity with the "
+ "scheme: "
+ scheme);
finish();
}
}
private boolean callWeChat() {
Uri contentUrl = Uri.parse(ConfigUtil.getString(Keys.URL_WECHAT));
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.addCategory(Intent.CATEGORY_BROWSABLE);
intent.setData(contentUrl);
PackageManager pm = getPackageManager();
List<ResolveInfo> resInfo = pm.queryIntentActivities(intent, 0);
Collections.sort(resInfo, new ResolveInfo.DisplayNameComparator(pm));
List<Intent> targetedIntents = new ArrayList<Intent>();
for (ResolveInfo info : resInfo) {
Intent targeted = new Intent(Intent.ACTION_VIEW);
ActivityInfo activityInfo = info.activityInfo;
if (activityInfo.packageName.equals("com.tencent.mm")) {
targeted.setData(contentUrl);
targeted.setPackage(activityInfo.packageName);
targeted.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
targetedIntents.add(targeted);
}
}
if (targetedIntents.isEmpty()) {
return false;
}
Intent chooser =
Intent.createChooser(targetedIntents.remove(0), getString(R.string.title_choose_wechat));
chooser.setClassName("android", "com.android.internal.app.ResolverActivity");
chooser.putExtra(Intent.EXTRA_INITIAL_INTENTS, targetedIntents.toArray(new Parcelable[] {}));
try {
startActivity(chooser);
} catch (ActivityNotFoundException e) {
return false;
}
return true;
}
/** {@inheritDoc} */
@Override
public void openActivityOrFragment(final Intent intent) {
final PackageManager pm = getPackageManager();
List<ResolveInfo> resolveInfoList =
pm.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
for (ResolveInfo resolveInfo : resolveInfoList) {
final FragmentReplaceInfo fri =
onSubstituteFragmentForActivityLaunch(resolveInfo.activityInfo.name);
if (fri != null) {
final Bundle arguments = intentToFragmentArguments(intent);
final FragmentManager fm = getSupportFragmentManager();
try {
Fragment fragment = (Fragment) fri.getFragmentClass().newInstance();
fragment.setArguments(arguments);
FragmentTransaction ft = fm.beginTransaction();
ft.replace(fri.getContainerId(), fragment, fri.getFragmentTag());
onBeforeCommitReplaceFragment(fm, ft, fragment);
ft.commit();
} catch (InstantiationException e) {
throw new IllegalStateException("Error creating new fragment.", e);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Error creating new fragment.", e);
}
return;
}
}
super.openActivityOrFragment(intent);
}
@Override
protected List<AppInfo> doInBackground(Void... v) {
final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
final PackageManager pm = getPackageManager();
final List<ResolveInfo> apps = pm.queryIntentActivities(mainIntent, 0);
final List<AppInfo> appList = new ArrayList<AppInfo>(apps.size());
for (ResolveInfo info : apps) {
final String packageName = info.activityInfo.packageName;
if (packageName == null) {
continue;
}
final String activityFqcn = info.activityInfo.name;
final CharSequence label = info.loadLabel(pm);
final Drawable icon = info.activityInfo.loadIcon(pm);
final AppInfo appInfo = new AppInfo(label.toString(), icon, activityFqcn, packageName);
appList.add(appInfo);
}
Collections.sort(
appList,
new Comparator<AppInfo>() {
@Override
public int compare(AppInfo app1, AppInfo app2) {
return app1.getLabel().compareTo(app2.getLabel());
}
});
return appList;
}
/**
* This method create a intent for posting a tweet on twitter by using the twitter app.
*
* @param tweetMessage message which should be posted
*/
public static void tweetWithApp(String tweetMessage) {
if (tweetMessage != null) {
Intent tweetIntent = new Intent(Intent.ACTION_SEND);
tweetIntent.putExtra(Intent.EXTRA_TEXT, tweetMessage);
tweetIntent.setType("text/plain");
tweetIntent.setFlags(
Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
PackageManager packManager = CreateContextForResource.getContext().getPackageManager();
List<ResolveInfo> resolvedInfoList =
packManager.queryIntentActivities(tweetIntent, PackageManager.MATCH_DEFAULT_ONLY);
boolean resolved = false;
for (ResolveInfo resolveInfo : resolvedInfoList) {
if (resolveInfo.activityInfo.packageName.startsWith("com.twitter.android")) {
tweetIntent.setClassName(
resolveInfo.activityInfo.packageName, resolveInfo.activityInfo.name);
resolved = true;
break;
}
}
if (resolved) {
CreateContextForResource.getContext().startActivity(tweetIntent);
} else {
Toast.makeText(
CreateContextForResource.getContext(),
CreateContextForResource.getStringFromID(R.string.twitter_not_found),
Toast.LENGTH_LONG)
.show();
}
}
}
protected List getData() {
List<Map> myData = new ArrayList<Map>();
Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
mainIntent.setPackage(getPackageName());
mainIntent.addCategory(Intent.CATEGORY_SAMPLE_CODE);
PackageManager pm = getPackageManager();
List<ResolveInfo> list = pm.queryIntentActivities(mainIntent, 0);
if (null == list) return myData;
int len = list.size();
String pkg = getPackageName();
for (int i = 0; i < len; i++) {
ResolveInfo info = list.get(i);
CharSequence labelSeq = info.loadLabel(pm);
if (info.activityInfo.packageName.equals(pkg) == false) {
continue;
}
String label = labelSeq != null ? labelSeq.toString() : info.activityInfo.name;
addItem(
myData,
label,
activityIntent(info.activityInfo.applicationInfo.packageName, info.activityInfo.name));
}
Collections.sort(myData, sDisplayNameComparator);
return myData;
}
/**
* 判断系统中是否存在可以启动的相机应用
*
* @return 存在返回true，不存在返回false
*/
public boolean hasCamera() {
PackageManager packageManager = mActivity.getPackageManager();
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
List<ResolveInfo> list =
packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
return list.size() > 0;
}
/**
* Get the {@link Entry} best associated with the given {@link Action}, or create and populate a
* new one if it doesn't exist.
*/
protected Entry getEntry(Action action) {
final String mimeType = action.getMimeType();
Entry entry = mCache.get(mimeType);
if (entry != null) return entry;
entry = new Entry();
final Intent intent = action.getIntent();
if (intent != null) {
final List<ResolveInfo> matches =
mPackageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
// Pick first match, otherwise best found
ResolveInfo bestResolve = null;
final int size = matches.size();
if (size == 1) {
bestResolve = matches.get(0);
} else if (size > 1) {
bestResolve = getBestResolve(intent, matches);
}
if (bestResolve != null) {
final Drawable icon = bestResolve.loadIcon(mPackageManager);
entry.bestResolve = bestResolve;
entry.icon = new SoftReference<Drawable>(icon);
}
}
mCache.put(mimeType, entry);
return entry;
}
final void openGoogleShopper(String query) {
// Construct Intent to launch Shopper
Intent intent = new Intent(Intent.ACTION_SEARCH);
intent.setClassName(GOOGLE_SHOPPER_PACKAGE, GOOGLE_SHOPPER_ACTIVITY);
intent.putExtra(SearchManager.QUERY, query);
// Is it available?
PackageManager pm = activity.getPackageManager();
Collection<?> availableApps =
pm.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
if (availableApps != null && !availableApps.isEmpty()) {
// If something can handle it, start it
activity.startActivity(intent);
} else {
// Otherwise offer to install it from Market.
AlertDialog.Builder builder = new AlertDialog.Builder(activity);
builder.setTitle(R.string.msg_google_shopper_missing);
builder.setMessage(R.string.msg_install_google_shopper);
builder.setIcon(R.drawable.shopper_icon);
builder.setPositiveButton(R.string.button_ok, shopperMarketListener);
builder.setNegativeButton(R.string.button_cancel, null);
builder.show();
}
}
private void openInMaps() {
// get preferences
SharedPreferences sharedPrefs =
PreferenceManager.getDefaultSharedPreferences(getActivity().getApplicationContext());
// build location from preferences
Uri location = Uri.parse("geo:0,0?q=" + sharedPrefs.getString("location", "94043"));
// build intent
Intent intent = new Intent(Intent.ACTION_VIEW, location);
// make sure theres an app available to respond by checking list of apps that can handle it is >
// 0
PackageManager packageManager = getActivity().getPackageManager();
List activities =
packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
boolean isIntentSafe = activities.size() > 0;
// start the intent only if its safe
if (isIntentSafe) {
startActivity(intent);
} else {
Toast.makeText(
getActivity().getApplicationContext(),
"Not apps to launch activity",
Toast.LENGTH_LONG)
.show();
}
}
public void testContentUri() {
Context context = getContext();
PackageManager packageManager = context.getPackageManager();
Intent intent = new Intent(Intent.ACTION_VIEW, ContactsContract.Contacts.CONTENT_URI);
List<ResolveInfo> resolveInfos = packageManager.queryIntentActivities(intent, 0);
assertFalse("Device does not support the activity intent: " + intent, resolveInfos.isEmpty());
}
public static List<ResolveInfo> findActivitiesForPackage(Context context, String packageName) {
final PackageManager packageManager = context.getPackageManager();
final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
mainIntent.setPackage(packageName);
final List<ResolveInfo> apps = packageManager.queryIntentActivities(mainIntent, 0);
return apps != null ? apps : new ArrayList<ResolveInfo>();
}
/**
* Returns all launchers of the specified package
*
* @param context The android context
* @param packageName The package name
* @return The resolve information of the specified package
*/
@TargetApi(Build.VERSION_CODES.DONUT)
public static List<ResolveInfo> getLaunchers(final Context context, final String packageName) {
final PackageManager pm = context.getPackageManager();
final Intent query = new Intent(Intent.ACTION_MAIN);
query.addCategory(Intent.CATEGORY_LAUNCHER);
query.setPackage(packageName);
return pm.queryIntentActivities(query, 0);
}
private static boolean isIntentAvailable(Context context, Intent intent) {
PackageManager mgr = context.getPackageManager();
if (mgr != null) {
List<ResolveInfo> list = mgr.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
return list.size() > 0;
}
return false;
}
private boolean isIntentHandlerAvailable(Intent intent) {
PackageManager pm = getActivity().getPackageManager();
List<ResolveInfo> list = pm.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
return list.size() > 0;
}
public static Drawable getIconForIntent(final Context context, Intent i) {
PackageManager pm = context.getPackageManager();
List<ResolveInfo> infos = pm.queryIntentActivities(i, PackageManager.MATCH_DEFAULT_ONLY);
if (infos.size() > 0) {
return infos.get(0).loadIcon(pm);
}
return null;
}
// intentに適したactivityを一覧で引いてくる処理。
private ArrayList<HashMap<String, String>> getSuitableActivities() {
ArrayList<HashMap<String, String>> apps = new ArrayList<HashMap<String, String>>();
//
List<ResolveInfo> list = new ArrayList<ResolveInfo>();
ResolveInfo info;
HashMap<String, String> appinfo;
//
final PackageManager pm = this.getPackageManager();
final Intent intent = new Intent();
intent.setAction(Intent.ACTION_VIEW);
intent.addCategory(Intent.CATEGORY_BROWSABLE);
intent.setData(Uri.parse("http://cnn.com/"));
List<ResolveInfo> list_src =
pm.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
if (list_src == null) {
return apps;
}
// いったんソートする
Collections.sort(list_src, new ResolveInfo.DisplayNameComparator(pm));
// listに対し、lastBrowserに等しいpackageNameを持っている要素を先頭に持ってくる
for (int i = 0; i < list_src.size(); i++) {
info = list_src.get(i);
if (mLastBrowser.equals((String) info.activityInfo.applicationInfo.packageName)) {
list.add(list_src.get(i));
}
}
// それ以外を後から追加する
for (int i = 0; i < list_src.size(); i++) {
info = list_src.get(i);
if (!mLastBrowser.equals((String) info.activityInfo.applicationInfo.packageName)) {
list.add(list_src.get(i));
}
}
// アクティビティ情報の取得
for (int i = 0; i < list.size(); i++) {
appinfo = new HashMap<String, String>();
info = list.get(i);
//
appinfo.put("label", (String) info.loadLabel(pm));
// Log.d(TAG, "gsa:label:" + (String) info.loadLabel(pm));
//
appinfo.put("packageName", (String) info.activityInfo.applicationInfo.packageName);
// Log.d(TAG, "gsa:pName:"
// + (String) info.activityInfo.applicationInfo.packageName);
//
appinfo.put("activityInfo", (String) info.activityInfo.name);
// Log.d(TAG, "gsa:aName:" + (String) info.activityInfo.name);
//
apps.add(appinfo);
}
return apps;
}
