Android SDK: चित्रों के लिए मेमोरी के आकार की सीमा से लड़ना

ड्राइंग एप्लिकेशन एक सरफेस व्यू और स्क्रीन-आकार वाले बिटमैप्स के एक जोड़े का उपयोग करता है (उदाहरण के लिए, मैं एक किताब में पृष्ठों की एक चिकनी पेजिंग दिखाना चाहता हूं)।

उच्च स्क्रीन रिज़ॉल्यूशन वाले कई उपकरणों पर, एप्लिकेशन एक त्रुटि के साथ क्रैश हो जाता है
AndroidRuntime: java.lang.OutOfMemoryError: बिटमैप का आकार VM बजट से अधिक है

समस्या यह है कि बिटमैप के लिए मेमोरी, साथ ही सर्फेस व्यू के लिए, एक सामान्य प्रक्रिया हीप से आरक्षित है। ढेर का आकार सीमा छोटा है, आमतौर पर 10 एमबी से थोड़ा अधिक। और सिस्टम को असेंबल करते समय यह सीमा निर्धारित की जाती है।

32 बिट्स से 16 तक पिक्सेल प्रारूप में कटौती करके स्थिति में सुधार करने का प्रयास ज्यादा मदद नहीं करता है। समस्या बाद में सामने आती है - उदाहरण के लिए, जब आप सरफेस व्यू के शीर्ष पर एक विंडो खोलते हैं (स्पष्ट रूप से, यह स्क्रीन के आकार को एक और बिटमैप बनाता है)।

कार्यक्रम के ग्राफिक बफ़र्स का आकार 3-4 स्क्रीन तक सीमित करना एक दुर्भाग्यपूर्ण कम है! आइए इस तरह के अन्याय को ठीक करने का प्रयास करें।

वास्तव में, बिटमैप की अधिकांश कार्यक्षमता देशी कोड (जेएनआई) में लागू की जाती है, और बफर को जावा हीप में नहीं, बल्कि एक नियमित शिश मॉलोक की मदद से आवंटित किया जाता है। उस पर ढेर आकार की सीमाएं क्यों लगाई गई हैं?

हम स्रोत कोड धूम्रपान करते हैं।

यह पता चलता है कि बिटमैप के लिए प्रत्येक मेमोरी आबंटन dalvik.system.VMRuntime में trackExternalAllocation / trackExternalFree तरीकों की मदद से पंजीकृत है। यह TrackExternalAllocation विधि है जो सीमा से अधिक स्मृति को आवंटित करने का प्रयास करते समय एक अपवाद फेंकता है।

क्या होगा अगर आप एक बेवकूफ रोबोट को धोखा देने की कोशिश करते हैं? तस्वीर को रखने के बाद, यह कहें कि आपके द्वारा कब्जा की गई बाहरी मेमोरी पहले से ही मुक्त है। और चित्र जारी करने से पहले, यह अनुकरण करें कि संबंधित मेमोरी का आकार बस कब्जा कर लिया गया है।

यह एक छोटी सी समस्या को दूर करने के लिए बनी हुई है - TrackExternalAllocation और trackExternalFree तरीके दिखाई नहीं देते हैं। हमें उन्हें "हैकर" तरीकों से कॉल करना होगा - प्रतिबिंब के माध्यम से।

हम इस विचार को लागू करने की कोशिश कर रहे हैं।
एक रिक्त Android अनुप्रयोग प्रोजेक्ट बनाएँ।

सुविधा के लिए, VMRuntime की पहुंच एक अलग वर्ग में कार्यान्वित की जाती है।

static class VMRuntimeHack { private Object runtime = null; private Method trackAllocation = null; private Method trackFree = null; public boolean trackAlloc(long size) { if (runtime == null) return false; try { Object res = trackAllocation.invoke(runtime, Long.valueOf(size)); return (res instanceof Boolean) ? (Boolean)res : true; } catch (IllegalArgumentException e) { return false; } catch (IllegalAccessException e) { return false; } catch (InvocationTargetException e) { return false; } } public boolean trackFree(long size) { if (runtime == null) return false; try { Object res = trackFree.invoke(runtime, Long.valueOf(size)); return (res instanceof Boolean) ? (Boolean)res : true; } catch (IllegalArgumentException e) { return false; } catch (IllegalAccessException e) { return false; } catch (InvocationTargetException e) { return false; } } public VMRuntimeHack() { boolean success = false; try { Class cl = Class.forName("dalvik.system.VMRuntime"); Method getRt = cl.getMethod("getRuntime", new Class[0]); runtime = getRt.invoke(null, new Object[0]); trackAllocation = cl.getMethod("trackExternalAllocation", new Class[] {long.class}); trackFree = cl.getMethod("trackExternalFree", new Class[] {long.class}); success = true; } catch (ClassNotFoundException e) { } catch (SecurityException e) { } catch (NoSuchMethodException e) { } catch (IllegalArgumentException e) { } catch (IllegalAccessException e) { } catch (InvocationTargetException e) { } if (!success) { Log.i(TAG, "VMRuntime hack does not work!"); runtime = null; trackAllocation = null; trackFree = null; } } } private static final VMRuntimeHack runtime = new VMRuntimeHack(); 

हम एक अलग वर्ग - कारखाने के रूप में बिटमैप बनाएंगे / जारी करेंगे।
यहां हम याद करेंगे कि किस बिटमैप के लिए हमने उपयोग की गई मेमोरी के बारे में जानकारी को ठीक किया - ताकि रिलीज पर वापस जाने के लिए मत भूलना।

  static class BitmapFactory { public BitmapFactory(boolean useHack) { this.useHack = useHack; } //   public Bitmap alloc(int dx, int dy) { Bitmap bmp = Bitmap.createBitmap(dx, dy, Bitmap.Config.RGB_565); if (useHack) { runtime.trackFree(bmp.getRowBytes() * bmp.getHeight()); hackedBitmaps.add(bmp); } allocatedBitmaps.add(bmp); return bmp; } //   public void free(Bitmap bmp) { bmp.recycle(); if (hackedBitmaps.contains(bmp)) { runtime.trackAlloc(bmp.getRowBytes() * bmp.getHeight()); hackedBitmaps.remove(bmp); } allocatedBitmaps.remove(bmp); } //    (  ) public void freeAll() { for (Bitmap bmp : new LinkedList<Bitmap>(allocatedBitmaps)) free(bmp); } private final boolean useHack; private Set<Bitmap> allocatedBitmaps = new HashSet<Bitmap>(); private Set<Bitmap> hackedBitmaps = new HashSet<Bitmap>(); } 

अब हम एक परीक्षण लिखेंगे जो यह जांचता है कि क्या यह विधि काम करती है। TestAllocation () विधि मेगाबाइट छवियों की अधिकतम संख्या बनाने की कोशिश करेगी (जब तक कि OutOfMemory क्रैश या निर्दिष्ट सीमा समाप्त नहीं हो जाती)। UseHack ध्वज परीक्षण को हैक के साथ या बिना चलाने के लिए सेट करता है। विधि उस राशि को वापस करती है जो चित्रों के तहत लेने में सक्षम थी।

  public int testAllocation(boolean useHack, int maxAlloc) { System.gc(); BitmapFactory factory = new BitmapFactory(useHack); int allocated = 0; // AndroidRuntime: java.lang.OutOfMemoryError: bitmap size exceeds VM budget while (allocated < maxAlloc) { try { Bitmap bmp = factory.alloc(1024, 512); allocated += bmp.getRowBytes() * bmp.getHeight(); Log.i(TAG, "Bitmap bytes allocated " + allocated); } catch (OutOfMemoryError e) { Log.e(TAG, "Exception while allocation of bitmap, total size = " + allocated, e); break; } } factory.freeAll(); return allocated; } 

हम हैक के साथ और इसके बिना - Activ.onCreate () में परीक्षण कहेंगे।
हम स्क्रीन पर और लॉग में परिणाम दिखाएंगे। (लेआउट "मुख्य" को ठीक करने की आवश्यकता है - टेक्स्ट व्यू आईडी में जोड़ें, जिसके द्वारा हम पाठ को बदल देंगे)।

  public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // perform test int allocatedNormally = testAllocation(false, 48 * MB); int allocatedWithHack = testAllocation(true, 48 * MB); String msg = "normally: " + (allocatedNormally / MB) + " MB allocated " + "\nwith hack: " + (allocatedWithHack / MB) + " MB allocated"; Log.i(TAG, msg); // display results LayoutInflater inflater = LayoutInflater.from(this); View main = (View)inflater.inflate(R.layout.main, null); TextView text = (TextView)main.findViewById(R.id.text); text.setText(msg); setContentView(main); } 

इसलिए, परिणाम देखें और देखें:
03-07 09:43:37.233: I/bmphack(17873): normally: 10 MB allocated
03-07 09:43:37.233: I/bmphack(17873): with hack: 48 MB allocated


एक हैक के बिना, हम प्रत्येक 1 मेगाबाइट की सिर्फ 10 तस्वीरें बनाने में कामयाब रहे। एक हैक के साथ - अधिकतम संख्या जो हमने निर्दिष्ट की (48 मेगाबाइट)।
बड़े आकार के साथ, परीक्षण अभी भी मेरे सिम्युलेटर पर लटका दिया गया - ~ 58Mb के बाद।

मुझे उम्मीद है कि किसी को यह लेख मददगार लगे।