Autore Topic: problemi con ftp  (Letto 1221 volte)

Offline fieraf

  • Utente junior
  • **
  • Post: 88
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    Galaxy s 2
  • Sistema operativo:
    windows 7
problemi con ftp
« il: 17 Ottobre 2012, 11:19:22 CEST »
0
ciao ragazzi.
sto facendo una applicazione che mi invia dei file a un mio server ftp.
ho creato una classe apposta per il ftp, ma quando dall'activity principale la vado a chiamare mi da errore
se invece nella classe ftp creo un AsyncTask, tutto funziona,perché

potete aiutarmi?

grazie

Offline Franz78

  • Nuovo arrivato
  • *
  • Post: 4
  • Respect: 0
    • Mostra profilo
Re:problemi con ftp
« Risposta #1 il: 26 Febbraio 2013, 17:20:28 CET »
0
Ciao, io sto cercando un esempio di AsyncTask con ftp , premetto che sono novizio mi daresti un indicata? :)

Offline leru

  • Nuovo arrivato
  • *
  • Post: 14
  • Respect: 0
    • Mostra profilo
  • Sistema operativo:
    ubuntu11.10
Re:problemi con ftp
« Risposta #2 il: 01 Marzo 2013, 10:13:43 CET »
0
Prova questo codice

Codice (Java): [Seleziona]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.util.ArrayList;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;

import android.os.AsyncTask;

@SuppressWarnings("unused")
public class CustomHttpClient {
        /** The time it takes for our client to timeout */
    public static final int HTTP_TIMEOUT = 30 * 1000; // milliseconds
    public static String post_url;
    public static ArrayList<NameValuePair> post_postParameters;
   
    /** Single instance of our HttpClient */
    private static HttpClient mHttpClient;

    /**
     * Get our single instance of our HttpClient object.
     *
     * @return an HttpClient object with connection parameters set
     */

    private static HttpClient getHttpClient() {
        if (mHttpClient == null) {
            mHttpClient = new DefaultHttpClient();
            final HttpParams params = mHttpClient.getParams();
            HttpConnectionParams.setConnectionTimeout(params, HTTP_TIMEOUT);
            HttpConnectionParams.setSoTimeout(params, HTTP_TIMEOUT);
            ConnManagerParams.setTimeout(params, HTTP_TIMEOUT);
        }
        return mHttpClient;
    }

    @SuppressWarnings("rawtypes")
        public class Connection extends AsyncTask {
         
        @Override
        protected Object doInBackground(Object... arg0) {
            try {
                                connect();
                        } catch (ClientProtocolException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
            return null;
        }
 
    }

    /**
     * Performs an HTTP Post request to the specified url with the
     * specified parameters.
     *
     * @param url The web address to post the request to
     * @param postParameters The parameters to send via the request
     * @return The result of the request
     * @throws Exception
     */

    public static void executeHttpPost(String url, ArrayList<NameValuePair> postParameters) throws Exception {
        String result;
        post_url=url;
        post_postParameters=postParameters;
       
       
            }

    public void connect() throws ClientProtocolException, IOException {
                // TODO Auto-generated method stub
        BufferedReader in = null;
        try {
            HttpClient client = getHttpClient();
            HttpPost request = new HttpPost(post_url);
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(post_postParameters);
            request.setEntity(formEntity);
            HttpResponse response = client.execute(request);
            in = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));

            StringBuffer sb = new StringBuffer("");
            String line = "";
            String NL = System.getProperty("line.separator");
            while ((line = in.readLine()) != null) {
                sb.append(line + NL);
            }
            in.close();

            String result = sb.toString();
            GPSlogin.responseurl=result;
            //            return result;
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        }

        /**
     * Performs an HTTP GET request to the specified url.
     *
     * @param url The web address to post the request to
     * @return The result of the request
     * @throws Exception
     */

    public static String executeHttpGet(String url) throws Exception {
        BufferedReader in = null;
        try {
            HttpClient client = getHttpClient();
            HttpGet request = new HttpGet();
            request.setURI(new URI(url));
            HttpResponse response = client.execute(request);
            in = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));

            StringBuffer sb = new StringBuffer("");
            String line = "";
            String NL = System.getProperty("line.separator");
            while ((line = in.readLine()) != null) {
                sb.append(line + NL);
            }
            in.close();

            String result = sb.toString();
            return result;
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
« Ultima modifica: 05 Marzo 2013, 09:52:41 CET da Ricky` »

Offline Franz78

  • Nuovo arrivato
  • *
  • Post: 4
  • Respect: 0
    • Mostra profilo
Re:problemi con ftp
« Risposta #3 il: 05 Marzo 2013, 09:38:51 CET »
0
Ciao e grazie per la risposta,  studiero' il codice che hai postato,
ma questo non fa un post ?
io dovrei realizzare il classico upload del file con barra di avanzamento....

cmq grazie per la cortese risposta.

Offline leru

  • Nuovo arrivato
  • *
  • Post: 14
  • Respect: 0
    • Mostra profilo
  • Sistema operativo:
    ubuntu11.10
Re:problemi con ftp
« Risposta #4 il: 05 Marzo 2013, 10:48:34 CET »
0
Prova questo codice
Codice (Java): [Seleziona]
import java.io.FileInputStream;
import java.io.FileOutputStream;

import org.apache.commons.net.ftp.*;

import android.content.Context;
import android.util.Log;

public class MyFTPClient {
       
        //Now, declare a public FTP client object.

        private static final String TAG = "MyFTPClient";
        public FTPClient mFTPClient = null;

        //Method to connect to FTP server:
        public boolean ftpConnect(String host, String username,
                                  String password, int port)
        {
            try {
                mFTPClient = new FTPClient();
                // connecting to the host
                mFTPClient.connect(host, port);

                // now check the reply code, if positive mean connection success
                if (FTPReply.isPositiveCompletion(mFTPClient.getReplyCode())) {
                    // login using username & password
                    boolean status = mFTPClient.login(username, password);

                    /* Set File Transfer Mode
                     *
                     * To avoid corruption issue you must specified a correct
                     * transfer mode, such as ASCII_FILE_TYPE, BINARY_FILE_TYPE,
                     * EBCDIC_FILE_TYPE .etc. Here, I use
                     * for transferring text, image, and compressed files.
                     */

                    mFTPClient.setFileType(FTP.BINARY_FILE_TYPE);
                    mFTPClient.enterLocalPassiveMode();

                    return status;
                }
            } catch(Exception e) {
                Log.d(TAG, "Error: could not connect to host " + host );
            }

            return false;
        }

        //Method to disconnect from FTP server:

        public boolean ftpDisconnect()
        {
            try {
                mFTPClient.logout();
                mFTPClient.disconnect();
                return true;
            } catch (Exception e) {
                Log.d(TAG, "Error occurred while disconnecting from ftp server.");
            }

            return false;
        }

        //Method to get current working directory:

        public String ftpGetCurrentWorkingDirectory()
        {
            try {
                String workingDir = mFTPClient.printWorkingDirectory();
                return workingDir;
            } catch(Exception e) {
                Log.d(TAG, "Error: could not get current working directory.");
            }

            return null;
        }

        //Method to change working directory:

        public boolean ftpChangeDirectory(String directory_path)
        {
            try {
                mFTPClient.changeWorkingDirectory(directory_path);
            } catch(Exception e) {
                Log.d(TAG, "Error: could not change directory to " + directory_path);
            }

            return false;
        }

        //Method to list all files in a directory:

        public void ftpPrintFilesList(String dir_path)
        {
            try {
                FTPFile[] ftpFiles = mFTPClient.listFiles(dir_path);
                int length = ftpFiles.length;

                for (int i = 0; i < length; i++) {
                    String name = ftpFiles[i].getName();
                    boolean isFile = ftpFiles[i].isFile();

                    if (isFile) {
                        Log.i(TAG, "File : " + name);
                    }
                    else {
                        Log.i(TAG, "Directory : " + name);
                    }
                }
            } catch(Exception e) {
                e.printStackTrace();
            }
        }

        //Method to create new directory:

        public boolean ftpMakeDirectory(String new_dir_path)
        {
            try {
                boolean status = mFTPClient.makeDirectory(new_dir_path);
                return status;
            } catch(Exception e) {
                Log.d(TAG, "Error: could not create new directory named " + new_dir_path);
            }

         return false;
        }

        //Method to delete/remove a directory:

        public boolean ftpRemoveDirectory(String dir_path)
        {
            try {
                boolean status = mFTPClient.removeDirectory(dir_path);
                return status;
            } catch(Exception e) {
                Log.d(TAG, "Error: could not remove directory named " + dir_path);
            }

            return false;
        }

        //Method to delete a file:

        public boolean ftpRemoveFile(String filePath)
        {
            try {
                boolean status = mFTPClient.deleteFile(filePath);
                return status;
            } catch (Exception e) {
                e.printStackTrace();
            }

            return false;
        }

        //Method to rename a file:

        public boolean ftpRenameFile(String from, String to)
        {
            try {
                boolean status = mFTPClient.rename(from, to);
                return status;
            } catch (Exception e) {
                Log.d(TAG, "Could not rename file: " + from + " to: " + to);
            }

            return false;
        }

        //Method to download a file from FTP server:

        /**
         * mFTPClient: FTP client connection object (see FTP connection example)
         * srcFilePath: path to the source file in FTP server
         * desFilePath: path to the destination file to be saved in sdcard
         */

        public boolean ftpDownload(String srcFilePath, String desFilePath)
        {
            boolean status = false;
            try {
                FileOutputStream desFileStream = new FileOutputStream(desFilePath);;
                status = mFTPClient.retrieveFile(srcFilePath, desFileStream);
                desFileStream.close();

                return status;
            } catch (Exception e) {
                Log.d(TAG, "download failed");
            }

            return status;
        }

        //Method to upload a file to FTP server:

        /**
         * mFTPClient: FTP client connection object (see FTP connection example)
         * srcFilePath: source file path in sdcard
         * desFileName: file name to be stored in FTP server
         * desDirectory: directory path where the file should be upload to
         */

        public boolean ftpUpload(String srcFilePath, String desFileName,
                                 String desDirectory, Context context)
        {
            boolean status = false;
            try {
               // FileInputStream srcFileStream = new FileInputStream(srcFilePath);
               
                FileInputStream srcFileStream = context.openFileInput(srcFilePath);

                // change working directory to the destination directory
                //if (ftpChangeDirectory(desDirectory)) {
                    status = mFTPClient.storeFile(desFileName, srcFileStream);
                //}

                srcFileStream.close();
                return status;
            }
            catch (Exception e) {
                Log.d(TAG, "upload failed: " + e);
            }

            return status;
        }
}
« Ultima modifica: 05 Marzo 2013, 10:52:32 CET da Ricky` »

Offline Ricky`

  • Amministratore
  • Utente storico
  • *****
  • Post: 3489
  • Respect: +506
    • Github
    • Google+
    • rciovati
    • Mostra profilo
Re:problemi con ftp
« Risposta #5 il: 05 Marzo 2013, 10:52:59 CET »
0
leru usa il tag quando incolli del codice ;)

Offline Franz78

  • Nuovo arrivato
  • *
  • Post: 4
  • Respect: 0
    • Mostra profilo
Re:problemi con ftp
« Risposta #6 il: 05 Marzo 2013, 17:35:01 CET »
0
Grazie adesso me lo studio e poi ti dico
gentilissimo , spero di poter ricambiare presto!

Offline GabMarioPower

  • Moderatore globale
  • Utente senior
  • *****
  • Post: 606
  • Respect: +152
    • Github
    • Google+
    • gabrielemariotti
    • GabMarioPower
    • Mostra profilo
  • Play Store ID:
    GAB+MARIO+DEV
  • Sistema operativo:
    Ubuntu 14.04 , Win 10
Re:problemi con ftp
« Risposta #7 il: 06 Marzo 2013, 01:13:46 CET »
0
ciao ragazzi.
sto facendo una applicazione che mi invia dei file a un mio server ftp.
ho creato una classe apposta per il ftp, ma quando dall'activity principale la vado a chiamare mi da errore
se invece nella classe ftp creo un AsyncTask, tutto funziona,perché

potete aiutarmi?

grazie

Qualsiasi operazione di rete non può essere effettuata nel Main Thread.
Se all'interno di una activity lanci una network call, questa vive nel thread principale e perciò viene bloccata .
Questo evita che la tua videata venga bloccata fino al termine dell'operazione.

Se invece sposti la tua chiamata all'interno di un AsyncTask, questa operazione viene eseguita in modo asincrono e non determina alcun blocco, ma solo se è nel metodo doInBackground(). Gli altri metodi dell'AsyncTask infatti sono eseguiti nel Thread Principale.