कतार में सर्वर पर एकाधिक छवियों को अपलोड करें

Question

केस का उपयोग करें: सर्वर पर पृष्ठभूमि में कतार में छवियां अपलोड करें, छवियां वेब यूआरएल या छवि फ़ाइल फोन की मेमोरी पर संग्रहीत हो सकती हैं।

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

वर्तमान स्थिति: अभी, मैं छवियों को अपलोड करने Retrofit 1.9.0 में Multipart का उपयोग कर रहा था और इस सेवा कॉल गतिविधि के अंदर किया जा रहा था।

मैं रेट्रोफिट या सामान्य रूप से किसी भी अन्य लाइब्रेरी का उपयोग करके एक मल्टीपार्ट-POST अनुरोध को रद्द, रोक या फिर से शुरू करने में सक्षम नहीं हूं और एपीआई सेवा थ्रेड के साथ UI ईवेंट को कैसे टाई जाए। मैं सेवा से यूआई अपडेट कर सकता हूं, लेकिन मैं UI में किसी ईवेंट से (सेवा/फिर से शुरू/रद्द) सेवा में कुछ कैसे अपडेट करूं?

मुझे इस उपयोग के मामले के साथ कैसे आगे बढ़ना चाहिए? क्या मुझे सेवा का उपयोग करने की ज़रूरत है? क्या मैं सेवा में निष्पादित अनुरोधों के आधार पर किसी अन्य गतिविधि में प्रगति संकेतक दिखा सकता हूं? इस प्रक्रिया के लिए वास्तुकला क्या होना चाहिए? मुझे इसके लिए कोड की आवश्यकता नहीं है, लेकिन यदि इससे संबंधित कुछ उपयोगी संदर्भ हैं, तो मैं अंततः अपना दृष्टिकोण प्राप्त करने के लिए इसे पढ़ना और परीक्षण करना चाहता हूं।

Answer 1

यह है कि आप कैसे कर सकते हैं: यह छवि के पथ को पार करके डिवाइस से छवि अपलोड करने के लिए नमूना कोड है .. इसी प्रकार आप इसे छवि यूआरएल, चरणों के लिए कर सकते हैं चरण: 1) एक थ्रेड बनाएं जो प्रत्येक छवि के लिए भागो। 2) उसके बाद प्रत्येक छवि अपलोड आपको प्रतिक्रिया देगा। 3) अब प्रत्येक छवि के लिए आप अपना यूआई अपडेट कर सकते हैं।

//TODO: Multiple file upload 
public class FileUpload implements Runnable { 
    Context context; 
    String uploadApiUrl, uploadFilePath, fileType; 
    int uploadId; 
    LocalQueenDataBase localQueenDataBase; 
    Activity activity; 

    public FileUpload(Context context, ,String uploadApiUrl, String uploadFilePath, String fileType, int uploadId) { 
     this.context = context; 
     this.uploadApiUrl = uploadApiUrl; 
     this.uploadFilePath = uploadFilePath; 
     this.fileType = fileType; 
     this.uploadId = uploadId; 
     localQueenDataBase = new LocalQueenDataBase(context); 
     Thread uploader = new Thread(this); 
     uploader.start(); 
    } 

    @Override 
    public void run() { 
     try { 
      executeMultipartPost(); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 

    public void executeMultipartPost() throws Exception { 
     try { 
      String originalPath = uploadFilePath; 
      if (uploadFilePath == null) { 
       uploadFilePath = originalPath; 
      } 
      HttpClient httpclient = new DefaultHttpClient(); 
      HttpPost httppost = new HttpPost("your api url"); 
      httppost.addHeader("put your header if required") 
      FileBody bin = new FileBody(new File(uploadFilePath)); 
      StringBody fileTypeBody = new StringBody(fileType); 
      StringBody uploadIdBody = new StringBody(uploadId + ""); 

      MultipartEntity reqEntity = new MultipartEntity(); 
      reqEntity.addPart("file", bin); 
      reqEntity.addPart("fileType", fileTypeBody); 
      reqEntity.addPart("uploadId", uploadIdBody); 
      httppost.setEntity(reqEntity); 

      HttpResponse response = httpclient.execute(httppost); 
      HttpEntity resEntity = response.getEntity(); 
      String retSrc = EntityUtils.toString(resEntity);//Render your response 
      //TODO: update your UI for each uploaded image by creating the Handler 
      Message msg = handler.obtainMessage(); 
      handler.sendMessage(msg); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 
} 

final Handler handler = new Handler() { 
    @Override 
    public void handleMessage(Message msg) { 
     try { 
      uploadGalleryRecyclerAdapter = new UploadGalleryRecyclerAdapter(getApplicationContext(), PostUpdateActivity.this, localQueenDataBase.getGallery()); 
      postUpdateRV.setAdapter(uploadGalleryRecyclerAdapter); 
      if (localQueenDataBase.getGallery().size() > 3) 
       gallerylayoutManager.scrollToPosition(localQueenDataBase.getGallery().size() - 2); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
     super.handleMessage(msg); 
    } 
}; 

आशा है कि यह आपकी मदद करेगा।

Answer 2

मैं आपको स्क्वायर के टेप का उपयोग करने की अत्यधिक अनुशंसा करता हूं, जबकि आप अपनी अपलोडिंग एकाधिक फाइल/छवियों को एक बार उपयोग, दक्षता, त्रुटि प्रबंधन, क्यूइंग सिस्टम की आसानी से देख रहे हैं। आप समय में केवल एक फ़ाइल का उपयोग कर रहे हैं, तो

यह वही है Square's Tape:

टेप Android और जावा के लिए कतार से संबंधित वर्गों द्वारा का एक संग्रह है है किसी भी एंड्रॉयड Http ग्राहकों में बहु-भाग फाइल अपलोड के किसी भी उपयोग करने का प्रयास स्क्वायर, इंक

क्यूईफ़ाइल एक बिजली-तेज, लेनदेन, फ़ाइल-आधारित फीफो है। एक उदाहरण से जोड़ना और निकालना एक ओ (1) ऑपरेशन है और परमाणु है। लेखन तुल्यकालिक हैं; एक ऑपरेशन रिटर्न से पहले डेटा डिस्क पर लिखा जाएगा। अंतर्निहित फ़ाइल को जीवित रहने के लिए संरचित किया गया है और यहां तक ​​कि सिस्टम क्रैश भी हो रहा है और यदि एक उत्परिवर्ती परिवर्तन के दौरान आई/ओ अपवाद फेंक दिया जाता है, तो परिवर्तन निरस्त हो जाता है।

एक ऑब्जेक्ट्यूयूयू मनमानी वस्तुओं के क्रम का प्रतिनिधित्व करता है जिसे या तो फाइल सिस्टम (क्यूईफाइल के माध्यम से) या केवल स्मृति में समर्थित किया जा सकता है।

टास्कक्यूयू एक विशेष ऑब्जेक्ट कतार है जिसमें कार्य, वस्तुओं को निष्पादित करने की धारणा होती है। उदाहरण बाहरी निष्पादक द्वारा प्रबंधित किए जाते हैं जो संलग्न कार्यों को तैयार और निष्पादित करता है।

Answer 3

enter codepackage com.mohit.mom.multipleimage; 

import android.annotation.SuppressLint; 
import android.app.Activity; 
import android.app.ProgressDialog; 
import android.content.Context; 
import android.content.Intent; 
import android.graphics.Bitmap; 
import android.graphics.Bitmap.CompressFormat; 
import android.graphics.BitmapFactory; 
import android.os.AsyncTask; 
import android.os.Bundle; 
import android.os.StrictMode; 
import android.util.Log; 
import android.view.Gravity; 
import android.view.View; 
import android.view.ViewGroup; 
import android.widget.BaseAdapter; 
import android.widget.Button; 
import android.widget.GridView; 
import android.widget.ImageView; 
import android.widget.TextView; 
import android.widget.Toast; 
import org.apache.http.HttpEntity; 
import org.apache.http.HttpResponse; 
import org.apache.http.client.HttpClient; 
import org.apache.http.client.methods.HttpPost; 
import org.apache.http.entity.mime.MultipartEntity; 
import org.apache.http.entity.mime.content.ByteArrayBody; 
import org.apache.http.entity.mime.content.StringBody; 
import org.apache.http.impl.client.DefaultHttpClient; 
import org.apache.http.protocol.BasicHttpContext; 
import org.apache.http.protocol.HttpContext; 
import org.apache.http.util.EntityUtils; 
import java.io.ByteArrayOutputStream; 
import java.util.ArrayList; 

@SuppressLint("NewApi") 
public class MainActivity extends Activity { 
    private Button upload, pick; 
    private ProgressDialog dialog; 
    MultipartEntity entity; 
    GridView gv; 
    int count = 0; 
    public ArrayList<String> map = new ArrayList<String>(); 
    Bundle b; 
    TextView noImage; 
    HttpEntity resEntity; 

    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 
     StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder() 
       .permitAll().build(); 
     StrictMode.setThreadPolicy(policy); 
     b = getIntent().getExtras(); 

     noImage = (TextView) findViewById(R.id.noImage); 
     upload = (Button) findViewById(R.id.btnUpload); 
     pick = (Button) findViewById(R.id.btnPicture); 
     gv = (GridView) findViewById(R.id.gridview); 
     gv.setAdapter(new ImageAdapter(this)); 

     if (b != null) 
     { 
      ArrayList<String> ImgData = b.getStringArrayList("IMAGE"); 
      for (int i = 0; i < ImgData.size(); i++) 
      { 
       map.add(ImgData.get(i).toString()); 
      } 
     } else 
     { 
      noImage.setVisibility(View.VISIBLE); 
     } 

     upload.setOnClickListener(new View.OnClickListener() { 

      public void onClick(View v) 
      { 
       new ImageUploadTask().execute(count + "", "pk" + count + ".jpg"); 
      } 
     }); 

     pick.setOnClickListener(new View.OnClickListener() { 

      public void onClick(View v) { 
       Intent i3 = new Intent(MainActivity.this, UploadActivity.class); 
       startActivity(i3); 
      } 
     }); 

    } 

    class ImageUploadTask extends AsyncTask<String, Void, String> { 

     String sResponse = null; 

     @Override 
     protected void onPreExecute() { 
      // TODO Auto-generated method stub 
      super.onPreExecute(); 
      dialog = ProgressDialog.show(MainActivity.this, "Uploading", 
        "Please wait...", true); 
      dialog.show(); 
     } 

     @Override 
     protected String doInBackground(String... params) { 
      try { 

       String url = "yours url"; 
       int i = Integer.parseInt(params[0]); 
       Bitmap bitmap = decodeFile(map.get(i)); 
       HttpClient httpClient = new DefaultHttpClient(); 
       HttpContext localContext = new BasicHttpContext(); 
       HttpPost httpPost = new HttpPost(url); 
       entity = new MultipartEntity(); 

       ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
       bitmap.compress(CompressFormat.JPEG, 50, bos); 
       byte[] data = bos.toByteArray(); 

       entity.addPart("user_id", new StringBody("199")); 
       entity.addPart("club_id", new StringBody("10")); 
       entity.addPart("club_image", new ByteArrayBody(data, 
         "image/jpeg", params[1])); 

       httpPost.setEntity(entity); 
       HttpResponse response = httpClient.execute(httpPost); 
       resEntity = response.getEntity(); 
       sResponse = EntityUtils.toString(resEntity); 
       //HttpResponse response = httpClient.execute(httpPost,localContext); 
       //sResponse = EntityUtils.getContentCharSet(response.getEntity()); 

       System.out.println("sResponse : " + sResponse); 
      } catch (Exception e) { 
       if (dialog.isShowing()) 
        dialog.dismiss(); 
       Log.e(e.getClass().getName(), e.getMessage(), e); 

      } 
      return sResponse; 
     } 

     @Override 
     protected void onPostExecute(String sResponse) { 
      try { 
       if (dialog.isShowing()) 
        dialog.dismiss(); 

       if (sResponse != null) { 
        Toast.makeText(getApplicationContext(), 
          sResponse + " Photo uploaded successfully", 
          Toast.LENGTH_SHORT).show(); 
        count++; 
        if (count < map.size()) { 
         new ImageUploadTask().execute(count + "", "hm" + count 
           + ".jpg"); 
        } 
       } 

      } catch (Exception e) { 
       Toast.makeText(getApplicationContext(), e.getMessage(), 
         Toast.LENGTH_LONG).show(); 
       Log.e(e.getClass().getName(), e.getMessage(), e); 
      } 

     } 
    } 

    public Bitmap decodeFile(String filePath) { 
// Decode image size 
     BitmapFactory.Options o = new BitmapFactory.Options(); 
     o.inJustDecodeBounds = true; 
     BitmapFactory.decodeFile(filePath, o); 
// The new size we want to scale to 
     final int REQUIRED_SIZE = 1024; 
// Find the correct scale value. It should be the power of 2. 
     int width_tmp = o.outWidth, height_tmp = o.outHeight; 
     int scale = 1; 
     while (true) { 
      if (width_tmp < REQUIRED_SIZE && height_tmp < REQUIRED_SIZE) 
       break; 
      width_tmp /= 2; 
      height_tmp /= 2; 
      scale *= 2; 
     } 
     BitmapFactory.Options o2 = new BitmapFactory.Options(); 
     o2.inSampleSize = scale; 
     Bitmap bitmap = BitmapFactory.decodeFile(filePath, o2); 
     return bitmap; 
    } 

    private class ImageAdapter extends BaseAdapter 
    { 
     private Context mContext; 

     public ImageAdapter(Context c) 
     { 
      mContext = c; 
     } 

     public int getCount() 
     { 
      return map.size(); 
     } 

     public Object getItem(int position) 
     { 
      return null; 
     } 

     // create a new ImageView for each item referenced by the Adapter 
     public View getView(int position, View convertView, ViewGroup parent) { 
      ImageView imageView; 
      if (convertView == null) 
      { // if it's not recycled, initialize some 
       // attributes 
       imageView = new ImageView(mContext); 
       imageView.setLayoutParams(new GridView.LayoutParams(85, 85, 
         Gravity.CENTER)); 
       imageView.setScaleType(ImageView.ScaleType.FIT_XY); 
       imageView.setPadding(1, 1, 1, 1); 

      } 
      else 
      { 
       imageView = (ImageView) convertView; 
      } 
      //Bitmap bm=BitmapFactory.decodeFile(map.get(position)); 
      final BitmapFactory.Options options = new BitmapFactory.Options(); 
      options.inSampleSize = 8; 
      Bitmap bmp = BitmapFactory.decodeFile(map.get(position),options); 
      imageView.setImageBitmap(bmp); 
      return imageView; 
     } 

     @Override 
     public long getItemId(int position) { 
      // TODO Auto-generated method stub 
      return 0; 
     } 
    } 

    @Override 
    public void onBackPressed() { 
// TODO Auto-generated method stub 
     super.onBackPressed(); 
     MainActivity.this.finish(); 
    } 
}