एंड्रॉइड जिंजरब्रेड

Question

पर ब्लूटूथ पर बड़ी मात्रा में डेटा स्थानांतरित करना मैं एक एंड्रॉइड फोन से दूसरे समय में मनमाने ढंग से डेटा के मेगाबाइट के बारे में स्थानांतरित करने की कोशिश कर रहा हूं। वर्तमान में, से OutputStream के आसपास BufferedOutputStream के आस-पास DataOutputStream पर आकार, एक कमांड कोड और डेटा लिखता है।

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

क्या वहां कोई बफर भर रहा है जो भर रहा है? क्या यह सुनिश्चित करने के लिए मुझे कुछ और करने की ज़रूरत है कि सभी डेटा स्थानांतरित हो जाए?

प्रेषक और प्राप्तकर्ता के लिए मेरे कोड में नीचे हैं:

प्रेषक:

try { 

      DataOutputStream d = new DataOutputStream(new BufferedOutputStream(mmOutStream,buffer.length+8)); 
      //int b= buffer.length; 
      d.writeInt(buffer.length); 
      d.writeInt(command); 

      d.write(buffer); 
      d.flush(); 

     } catch (IOException e) { 
      Log.e(TAG, "Exception during write", e); 
     } 
    } 

रिसीवर:

try { 

       // Read from the InputStream 
       int messageSize= inStream.readInt(); 
       int messageCode = inStream.readInt(); 
       bytes=0; 
       buffer =new byte[messageSize]; 
       while(bytes < messageSize) 
       { 
        bytes += inStream.read(buffer,bytes,messageSize - bytes); 

       } 
        message = bytes; 
      } catch (IOException e) { 
       Log.e(TAG, "disconnected", e); 
       connectionLost(); 
       break; 
      } 

Answer 1

मेरी अंत पर कुछ और परीक्षण के बाद, मैं करने के लिए मेरे भेजने कोड बदल इस तरह दिखें:

for(int i=0; i<buffer.length;i+=BIG_NUM) 
      { 
       int b = ((i+BIG_NUM) < buffer.length) ? BIG_NUM: buffer.length - i; 
       d.write(buffer,i,b); 
       d.flush(); 
      } 

फाइलें अब भेजी जाती हैं। क्या किसी के पास कोई विचार है? क्या डेटा flush() पर कॉल करता है जब तक कि डेटा वास्तव में स्थानांतरित नहीं हो जाता है? क्या भेजने के आकार और बफर प्राप्त करने के आकार के बारे में कोई दस्तावेज है जो मुझे यह तय करने में मदद करेगा कि मैं सुरक्षित रूप से BIG_NUM कैसे सुरक्षित कर सकता हूं?

Answer 2

मुझे एक ही समस्या है, फ़ाइल भेजते समय कुछ हिस्सों में गायब हैं। मैं BufferedOutputStream कोशिश करें लेकिन समस्या अभी भी मौजूद है।

अंत में मैं सरल समाधान खोजने:

आप बफर लंबाई भेजने की जरूरत नहीं है, बस बाइट सरणी के लिए बफर भेजने (उदाहरण के लिए [8192]) और पर पक्ष प्राप्त सुनिश्चित करें कि इस बफर बहुत बड़ा है विभाजित बफर भेजने से लगभग 4 या 8 बार। यह मेरे लिए काम करता है और फ़ाइल भेज दी जाती है।