देरी के साथ कैनवास पर ड्रा करें - "ऑन ड्रा() धीमा कर दें"

Question

मैं ड्रॉक्रिकल और एंड्रॉइड में ड्रॉपॉइंट जैसे कैनवास के लिए फ़ंक्शंस का उपयोग करता हूं। यह ठीक काम करता है।

लेकिन समस्या अब इन अलग-अलग वस्तुओं को देरी से आकर्षित करना है, इसलिए यह एक एनीमेशन की तरह दिखता है।

मुझे किस प्रकार की तंत्र का उपयोग करना चाहिए? async के साथ की कोशिश की है, लेकिन मैं यह कर की कि जिस तरह से पसंद नहीं।

क्या मुझे किसी प्रकार का टाइमर उपयोग करना चाहिए जो सिर्फ अंतराल के साथ खींचे या क्या ऐसा करने के लिए अन्य चालाक तरीके हैं?

Answer 1

मैं इस रणनीति का प्रयोग, पहले मैं एक हैंडलर घोषणा और एक Runnable कि जिस तरह से है mTimeManager.run() और यह मेरी Observer रों सूचित करने के लिए (पूर्व में जोड़े) समय-समय पर शुरू कर देंगे।

आप किसी कारण से की जरूरत है टाइमर या कुछ ठीक यही करने को रोकने:

mHandler.removeCallbacks(mTimeManager); 

[संपादित करें - अधिक पूरा कोड]

ठीक से चलो यह स्पष्ट करने के लिए, पहले मैंने बनाया ऐसे ही एक कस्टम प्रत्यक्ष वस्तु [वह वैकल्पिक है]:

private final Observable mObservable = new Observable() 
    { 
     public void notifyObservers() 
     { 
      setChanged(); 
      super.notifyObservers(); 
     }; 

     @Override 
     public void notifyObservers(Object data) 
     { 
      setChanged(); 
      super.notifyObservers(data); 
     }; 
    }; 

कि के लिए कारण बस है, क्योंकि मैं setChan कॉल नहीं कर सकते GED() प्रत्यक्ष कक्षा के बाहर - यह संरक्षित है अगर यह यह किसी भी पर्यवेक्षक सूचित नहीं करता नहीं बदल गया है।

अन्य घोषणाओं ही रखने के रूप में पहले से पता चला है, अब मैं इस TimeManager कहीं शुरू करने की आवश्यकता, मेरे ऐप एक LiveWallpaper है और मैं एक वर्ग है कि एक Thread फैली में सभी प्रतिपादन सामान बनाने, लेकिन आप जरूरी है कि जरूरत नहीं है, मैं इस एक Thread वर्ग से public synchronized void start() की मेरी @Override पर super.start(); सही होने के बाद कहा जाता है resumeDrawing() नामक एक विधि बनाया है, विधि की तरह दिखता है:

public void resumeDrawing() 
    { 
     if (!mTimeManagerRunning) // just a boolean field in my class 
     { 
      System.err.println("Resuming renderer."); // just for debug 
      mTimeManager.run(); 
      mTimeManagerRunning = true; 
     } 
     else 
     { 
      System.err.println("Renderer already running."); // just for debug 
     } 
    } 

और यह दोहरी है:

public void pauseDrawing() 
    { 
     if (mTimeManagerRunning) 
     { 
      System.err.println("Pausing renderer."); 
      mHandler.removeCallbacks(mTimeManager); 
      mTimeManagerRunning = false; 
     } 
     else 
     { 
      System.err.println("Renderer already paused."); 
     } 
    } 

ठीक है, अब हम शुरू कर सकते हैं और समय प्रबंधक रोक है, लेकिन जो सुन रहा है? कोई भी नहीं!के इतने जाने add'em: मेरे प्रतिपादक के निर्माता पर मैं अपने mObservable वस्तु के लिए कुछ Observer रों जोड़ने के लिए, उन में से एक, प्रतिपादक ही है तो मेरी रेंडरर Thread प्रदान करता है और Observer लागू करता है:

@Override // from Observer interface 
    public void update(Observable arg0, Object arg1) 
    { 
     mElapsedMsRedraw += (Integer) arg1; 

     if (mElapsedMsRedraw >= mDrawingMsPerFrame) 
     { 
      mElapsedMsRedraw = 0; 
      drawEm(); // refresh the canvas and stuff 
     } 
    } 

पर्यवेक्षकों आप जोड़ना बस करना mObservable.addObserver(THE_OBJECT - Implements Observer)

आप देख सकते हैं कि मैं नहीं मेरा सामान हर बार मैं अधिसूचित कर रहा हूँ फिर से प्रस्तुत करना है, कि क्योंकि मैं के लिए इस TimeManager का उपयोग अन्य सोचता है की तुलना में सिर्फ वस्तुओं मैं चाहता हूँ की स्थिति को अद्यतन करने की तरह Canvas ताज़ा आंतरिक रूप से आकर्षित करने के लिए।

तो, ड्राइंग को धीमा करने के लिए आपको क्या करना है, समय बीतने के दौरान आंतरिक रूप से आपके ऑब्जेक्ट्स को बदलने का तरीका बदलना है, मेरा मतलब है कि आपकी मंडलियां और अंक इत्यादि, या आप अपना समय तय कर सकते हैं, मैं पहले की सिफारिश करता हूं।

क्या यह स्पष्ट था? मुझे उम्मीद है यह मदद करेगा।

Answer 2

मैं टाइमर का उपयोग करता हूं, या एनिमेशन बनाउंगा। आप एनिमेशन कि समय के साथ पारदर्शिता को बदलने सहित चीजों के सभी प्रकार के हो जाएगा बना सकते हैं।

private final Observable mObservable = new Observable(); 
    private final static int TIME_STEP_MS = 5; 
    private final Handler mHandler = new Handler(); 
    private final Runnable mTimeManager = new Runnable() 
    { 
     public void run() 
     { 
      mObservable.notifyObservers(TIME_STEP_MS); 
      mHandler.postDelayed(mTimeManager, TIME_STEP_MS); 
     } 
    }; 

फिर जब मैं अपना समय प्रबंधक शुरू करना चाहते हैं मैं सिर्फ फोन:

यहाँ एनीमेशन संसाधन के लिए Android Documentation

Answer 3

मेरा मानना ​​है कि वहाँ ऐसा करने का परिष्कृत तरीके हो सकता है लेकिन मेरी जरूरतों के लिए मैं एक सरल विधि फायदे का एक बहुत है कि प्रयोग किया है: मैं पहली बार हर बिंदु के लिए रिकॉर्ड निर्देशांक के (और किसी भी अन्य डेटा आवश्यक) बनाने ड्राइंग के बजाय - स्पॉट पर अंक खींचने के बजाय - और फिर टाइमर (एंड्रॉइड हैंडलर, अधिमानतः) का उपयोग करके उन्हें पुन: उत्पन्न करें। यह वास्तविक ड्राइंग के दौरान कई संभावनाएं भी प्रदान करता है: रोकें, तेज़/धीमे हो जाएं, पीछे जाएं, ... मुझे नहीं पता कि इस विधि को जटिल चित्रों के लिए उपयोग किया जा सकता है, लेकिन यह आकार, वक्र, सतह, आदि