दिलचस्प पोस्ट
आप टेक्स्टरिए में कर्सर की स्थिति कैसे प्राप्त करते हैं? एलएक्सएमएल में एक टैग के अंदर सभी पाठ प्राप्त करें फोनगैप ग्रहण समस्या – ईग्लोकेडैकॉन ग्लूल्ट्स पैरामाइसः अनकही परम त्रुटियां मोबाइल वेब के लिए अधिकतम-डिवाइस-चौड़ाई और अधिकतम-चौड़ाई के बीच क्या अंतर है? खाका मेटाप्राग्राम रूपांतरण प्रकार को अनन्य नंबर पर जब java.lang को पकड़ने के लिए। त्रुटि? एनजीएफएआर के साथ एक जेसन ऑब्जेक्ट को दोहराएं आप विंडोज में पाथ एंटरप्राइज व्हेरिएबल से अधिक कैसे बचना चाहते हैं? Android TextView में पाठ कर्निंग को कैसे समायोजित करें? फ़ंक्शन कॉल पर टाइमआउट संपादन टेक्स्ट फ़ील्ड के साथ शॉर्ट कीबोर्ड ओवरलैप करना IOS8 इंटरएक्टिव सूचना को कैसे कार्यान्वित करें I Socket.IO 1.x और Express 4.x के साथ सत्र कैसे साझा करें? PHP का उपयोग करके HTML को पीडीएफ में परिवर्तित करना (पीडीएफ से HTML नहीं) घटनाओं के माध्यम से WPF कॉलिंग आदेश

एंड्रॉइड में एक ऐप गैर-सिस्टीम ऐप है, तो मैं कैसे जांचूं?

मुझे PackageManager.getInstalledApplications (0) के साथ ApplicationInfo ऑब्जेक्ट की एक सूची मिल रही है और उन्हें एक सिस्टम एप्लिकेशन के रूप में वर्गीकृत करने की कोशिश कर रहा है या नहीं

थोड़ी देर के लिए मैं यहाँ वर्णित तकनीक का उपयोग कर रहा हूं, हालांकि यह देखते हुए कि मेरे आवेदन में, कुछ ऐप्स गैर-सिस्टम ऐप की सूची में नहीं थे (जैसे कि फेसबुक , जो उपलब्ध होने पर सिस्टम को एसडी पर स्थापित करने के लिए कहता है कार्ड)। AppInfo.FLAG_SYSTEM के लिए वास्तविक दस्तावेज पढ़ने के बाद, और यह समझते हैं कि यह वास्तव में सिस्टम ऐप्स को फ़िल्टर नहीं करता है, अब मैं एक नए दृष्टिकोण की तलाश कर रहा हूं।

मेरा अनुमान है कि सिस्टम और गैर-सिस्टम ऐप्स के यूआईडी के बीच एक बड़ा अंतर है, जिसे मैं इस अंतर को बनाने के लिए इकट्ठा कर सकता हूं, लेकिन अभी तक मुझे कोई जवाब नहीं मिला है। मैंने भी अन्य झंडे में देखा, जैसे कि ApplicationInfo.FLAG_EXTERNAL_STORAGE , हालांकि मैं एपीआई 1.5 का समर्थन कर रहा हूं।

क्या किसी के पास इस का वास्तविक हल है ( FLAG_SYSTEM को शामिल नहीं करना)?

Solutions Collecting From Web of "एंड्रॉइड में एक ऐप गैर-सिस्टीम ऐप है, तो मैं कैसे जांचूं?"

 PackageManager pm = mcontext.getPackageManager(); List<PackageInfo> list = pm.getInstalledPackages(0); for(PackageInfo pi : list) { ApplicationInfo ai = pm.getApplicationInfo(pi.packageName, 0); System.out.println(">>>>>>packages is<<<<<<<<" + ai.publicSourceDir); if ((ai.flags & ApplicationInfo.FLAG_SYSTEM) != 0) { System.out.println(">>>>>>packages is system package"+pi.packageName); } } 

मैं इस धारणा के तहत था कि सिस्टम छवि में सभी ऐप्स सिस्टम एप्लिकेशन हैं (और आमतौर पर /system/app में स्थापित)

अगर FLAG_SYSTEM केवल सिस्टम एप्लिकेशन पर सेट है, तो यह बाहरी संग्रहण में भी ऐप्स के लिए काम करेगा:

 boolean isUserApp(ApplicationInfo ai) { int mask = ApplicationInfo.FLAG_SYSTEM | ApplicationInfo.FLAG_UPDATED_SYSTEM_APP; return (ai.flags & mask) == 0; } 

वैकल्पिक रूप से अपने फोन में pm कमांड लाइन कार्यक्रम का उपयोग करना है।

वाक्य – विन्यास:

 pm list packages [-f] [-d] [-e] [-s] [-3] [-i] [-u] [--user USER_ID] [FILTER] pm list packages: prints all packages, optionally only those whose package name contains the text in FILTER. Options: -f: see their associated file. -d: filter to only show disbled packages. -e: filter to only show enabled packages. -s: filter to only show system packages. -3: filter to only show third party packages. -i: see the installer for the packages. -u: also include uninstalled packages. 

कोड:

 ProcessBuilder builder = new ProcessBuilder("pm", "list", "packages", "-s"); Process process = builder.start(); InputStream in = process.getInputStream(); Scanner scanner = new Scanner(in); Pattern pattern = Pattern.compile("^package:.+"); int skip = "package:".length(); Set<String> systemApps = new HashSet<String>(); while (scanner.hasNext(pattern)) { String pckg = scanner.next().substring(skip); systemApps.add(pckg); } scanner.close(); process.destroy(); 

फिर:

 boolean isUserApp(String pckg) { return !mSystemApps.contains(pckg); } 

आप उस एप्लिकेशन के हस्ताक्षर की जांच कर सकते हैं जो सिस्टम के साथ हस्ताक्षरित है। नीचे की तरह

 /** * Match signature of application to identify that if it is signed by system * or not. * * @param packageName * package of application. Can not be blank. * @return <code>true</code> if application is signed by system certificate, * otherwise <code>false</code> */ public boolean isSystemApp(String packageName) { try { // Get packageinfo for target application PackageInfo targetPkgInfo = mPackageManager.getPackageInfo( packageName, PackageManager.GET_SIGNATURES); // Get packageinfo for system package PackageInfo sys = mPackageManager.getPackageInfo( "android", PackageManager.GET_SIGNATURES); // Match both packageinfo for there signatures return (targetPkgInfo != null && targetPkgInfo.signatures != null && sys.signatures[0] .equals(targetPkgInfo.signatures[0])); } catch (PackageManager.NameNotFoundException e) { return false; } } 

आप अपने ब्लॉग पर अधिक कोड प्राप्त कर सकते हैं यह जांचने के लिए कि क्या एप्लिकेशन सिस्टम ऐप है या नहीं (हस्ताक्षर किए हस्ताक्षर द्वारा)

खैर, मेरी राय में यह एक ढीली समाधान है (क्या होगा यदि / डेटा / ऐप सभी डिवाइस पर ऐप्स डायरेक्टरी नहीं है?), लेकिन पूरी तरह से खोज के बाद, यह है कि मैं इसके साथ आया हूं:

 for (ApplicationInfo ai : appInfo) { if (ai.sourceDir.startsWith("/data/app/")) { //Non-system app } else { //System app } } 

यहां कुछ गलतफहमी है एंड्रॉइड के लिए "सिस्टम एप" की धारणा एक है जो कि सिस्टम छवि पर स्थापित है, यह कुछ नहीं बताता है कि यह डेवलपर किस बारे में आया है। इसलिए, यदि कोई OEM सिस्टम छवि पर फेसबुक को प्रीलोड करने का निर्णय करता है, तो यह एक सिस्टम ऐप है और यह तब भी जारी रहेगा, चाहे एप्लिकेशन के अपडेट्स को इंस्टॉल किए जाने पर भी। वे सिस्टम छवि पर स्थापित नहीं होंगे, निश्चित रूप से, क्योंकि यह केवल पढ़ने के लिए है

तो ApplicationInfo.FLAG_SYSTEM सही है, लेकिन वह ऐसा प्रश्न नहीं है जो आप पूछ रहे हैं। मुझे लगता है कि आप पूछ रहे हैं कि क्या कोई सिस्टम सिस्टम प्रमाण पत्र के साथ हस्ताक्षरित है। यह जरूरी नहीं कि किसी भी चीज़ का अच्छा संकेतक है, यह डिवाइस से डिवाइस में भिन्न हो सकता है और वेनिला एंड्रॉइड पर कुछ आश्चर्यजनक घटकों को सिस्टम प्रमाणपत्र के साथ हस्ताक्षर नहीं किया जाता है, भले ही आप उन्हें उम्मीद कर सकते हैं

एंड्रॉइड के नए संस्करणों में एक नया पथ, / सिस्टम / प्राइव-ऐप / है, जो कि "वास्तविक" प्रणाली क्षुधा के लिए स्थापित स्थान होने का प्रयास करता है। वे ऐप्स जो सिस्टम छवि पर पहले ही लोड किए जाते हैं, तो / system / app / में समाप्त हो जाते हैं AOSP Privileged बनाम सिस्टम ऐप देखें

यदि कोई अनुप्रयोग एक गैर-सिस्टम एप्लिकेशन है तो उसे लॉन्च इंटेंट होना चाहिए जिसके द्वारा इसे लॉन्च किया जा सकता है। अगर लांच इरादे शून्य है तो इसकी एक प्रणाली ऐप

सिस्टम ऐप्स का उदाहरण: "com.android.browser.provider", "com.google.android.voicesearch"

उपरोक्त एप्लिकेशन के लिए जब आप लॉन्च इंटेंट के लिए क्वेरी करते हैं तो आपको नल मिलेगा।

 PackageManager pm = getPackageManager(); List<ApplicationInfo> packages = pm.getInstalledApplications(PackageManager.GET_META_DATA); for(ApplicationInfo packageInfo:packages){ if( pm.getLaunchIntentForPackage(packageInfo.packageName) != null ){ String currAppName = pm.getApplicationLabel(packageInfo).toString(); //This app is a non-system app } } 
 if (!packageInfo.sourceDir.toLowerCase().startsWith("/system/")) 

गैर-सिस्टम अनुप्रयोगों के 2 प्रकार हैं:

  1. Google Play Store से डाउनलोड किए गए एप्लिकेशन
  2. मैनुफ्केचरर द्वारा उपकरण में पहले से लोड किए गए ऐप्स

नीचे दिए गए सभी कोड सभी उपरोक्त अनुप्रयोगों की सूची वापस करेगा:

 ArrayList<ApplicationInfo> mAllApp = mPackageManager.getInstalledApplications(PackageManager.GET_META_DATA); for(int i = 0; i < mAllApp.size(); i++) { if((mAllApp.get(i).flags & ApplicationInfo.FLAG_SYSTEM) == 0) { // 1. Applications downloaded from Google Play Store mAllApp1.add(mAllApp.get(i)); } if((mAllApp.get(i).flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) { // 2. Applications preloaded in device by manufecturer mAllApp1.add(mAllApp.get(i)); } } 

यदि एक एपीके फ़ाइल है और यह देखना है कि सिस्टम ऐप या यूज़र ने एक सरल तर्क स्थापित किया है: – सिस्टम ऐप फ़ाइलें लेखन योग्य नहीं हैं

 private boolean isSystemApkFile(File file){ return !file.canWrite(); } 

यहाँ एक ऐप है जिसके लिए मैंने उस उद्देश्य के लिए लिखा था।
उपयोग का उदाहरण:

 new AppsUtil(this).printInstalledAppPackages(AppsUtil.AppType.USER); 

AppsUtil.java

 import java.util.ArrayList; import java.util.List; import android.content.Context; import android.content.pm.ApplicationInfo; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; import android.content.pm.PackageManager.NameNotFoundException; import android.util.Log; public class AppsUtil { public static final String TAG = "PackagesInfo"; private Context _context; private ArrayList<PckgInfo> _PckgInfoList; public enum AppType { ALL { @Override public String toString() { return "ALL"; } }, USER { @Override public String toString() { return "USER"; } }, SYSTEM { @Override public String toString() { return "SYSTEM"; } } } class PckgInfo { private AppType appType; private String appName = ""; private String packageName = ""; private String versionName = ""; private int versionCode = 0; private void prettyPrint() { Log.i(TAG, appName + "\n AppType: " + appType.toString() + "\n Package: " + packageName + "\n VersionName: " + versionName + "\n VersionCode: " + versionCode); } } public AppsUtil(Context context) { super(); this._context = context; this._PckgInfoList = new ArrayList<PckgInfo>(); } public void printInstalledAppPackages(AppType appType) { retrieveInstalledAppsPackages(); Log.i(TAG, ""); for (int i = 0; i < _PckgInfoList.size(); i++) { if (AppType.ALL == appType) { _PckgInfoList.get(i).prettyPrint(); } else { if (_PckgInfoList.get(i).appType == appType) _PckgInfoList.get(i).prettyPrint(); } } } public ArrayList<PckgInfo> getInstalledAppPackages(AppType appType) { retrieveInstalledAppsPackages(); ArrayList<PckgInfo> resultPInfoList = new ArrayList<PckgInfo>(); if (AppType.ALL == appType) { return _PckgInfoList; } else { for (int i = 0; i < _PckgInfoList.size(); i++) { if (_PckgInfoList.get(i).appType == appType) resultPInfoList.add(_PckgInfoList.get(i)); } return resultPInfoList; } } private void retrieveInstalledAppsPackages() { PackageManager pm = _context.getPackageManager(); List<PackageInfo> packs = pm.getInstalledPackages(0); for (PackageInfo pi : packs) { try { PckgInfo newInfo = new PckgInfo(); ApplicationInfo ai = pm.getApplicationInfo(pi.packageName, 0); newInfo.appType = getAppType(ai); newInfo.appName = pi.applicationInfo.loadLabel(pm).toString(); newInfo.packageName = pi.packageName; newInfo.versionName = pi.versionName; newInfo.versionCode = pi.versionCode; _PckgInfoList.add(newInfo); } catch (NameNotFoundException e) { e.printStackTrace(); } } } AppType getAppType(ApplicationInfo ai) { AppType resultType ; if (isUserApp(ai)) resultType = AppType.USER; else resultType = AppType.SYSTEM; return resultType; } boolean isUserApp(ApplicationInfo ai) { int mask = ApplicationInfo.FLAG_SYSTEM | ApplicationInfo.FLAG_UPDATED_SYSTEM_APP; return (ai.flags & mask) == 0; } }