none
Protocolo Imap4 no Windows Phone 7 RRS feed

  • Pergunta

  • Olá,

     

     Estou com grande problema estou procurando um biblioteca, ou uma forma de receber e enviar email usando o protocolo Imap4, to tentando usar socket e também não conseguir realizar a autenticação.

     

    Alguem pode me ajudar?

    quinta-feira, 24 de novembro de 2011 11:44

Respostas

Todas as Respostas

  • Francamente não tenho conhecimento de alguma biblioteca de Imap4 para o Windows Phone, mas no CodePlex aparecem algumas, pode ser que consigas usar uma...

    http://www.codeplex.com/site/search?query=imap&sortBy=Relevance&licenses=|&ac=8


    Pedro Lamas
    DevScope | Senior Solution Developer & WP7 Development Speaker
    www.pedrolamas.com | @pedrolamas
    • Marcado como Resposta Fernando Figuera segunda-feira, 2 de abril de 2012 19:32
    quinta-feira, 24 de novembro de 2011 18:18
  • Francamente não tenho conhecimento de alguma biblioteca de Imap4 para o Windows Phone, mas no CodePlex aparecem algumas, pode ser que consigas usar uma...

    http://www.codeplex.com/site/search?query=imap&sortBy=Relevance&licenses=|&ac=8


    Pedro Lamas
    DevScope | Senior Solution Developer & WP7 Development Speaker
    www.pedrolamas.com | @pedrolamas

    Oi Pedro,

     

    Ver so conseguir usar socket para se conectar, mas o retorno do esta vindo totalmente errado no metodo received, veja o codigo abaixo:

    O SERVER : imap.gmail.com , porta : 993

    enviar um informaçao atraves metodo send: A1 LOGIN EMAIL@GMAIL.COM SENHA (ai vc altera email e senha)

     

    ao retorna informaçoes do server : Esta vindo com uma string "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\00\0\0\0\0\0\0\0\0" em vez de "OK email (Sucess)".

     

    Já troquei o tipo UTF8 para Unicode mas nao funcionou.

     

    Alguem tem alguma ideia?

    using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Threading;
    using System.Text;

    namespace samples_imap
    {
        public class SocketClient
        {

         
            // Cached Socket object that will be used by each call for the lifetime of this class
            Socket _socket = null;

            // Signaling object used to notify when an asynchronous operation is completed
            static ManualResetEvent _clientDone = new ManualResetEvent(false);

            // Define a timeout in milliseconds for each asynchronous call. If a response is not received within this
            // timeout period, the call is aborted.
            const int TIMEOUT_MILLISECONDS = 5000;

            // The maximum size of the data buffer to use with the asynchronous socket methods
            const int MAX_BUFFER_SIZE = 2048;


            public string Connect(string hostName, int portNumber)
            {
                string result = string.Empty;



                // Create DnsEndPoint. The hostName and port are passed in to this method.
                DnsEndPoint hostEntry = new DnsEndPoint("imap.gmail.com", 993);

              

                // Create a stream-based, TCP socket using the InterNetwork Address Family.
                _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                // Create a SocketAsyncEventArgs object to be used in the connection request
                SocketAsyncEventArgs socketEventArg = new SocketAsyncEventArgs();
                socketEventArg.RemoteEndPoint = hostEntry;

                // Inline event handler for the Completed event.
                // Note: This event handler was implemented inline in order to make this method self-contained.
                socketEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(delegate(object s, SocketAsyncEventArgs e)
                {
                    // Retrieve the result of this request
                    result = e.SocketError.ToString();

               

                    // Signal that the request is complete, unblocking the UI thread
                    _clientDone.Set();
                });

                // Sets the state of the event to nonsignaled, causing threads to block
                _clientDone.Reset();

                // Make an asynchronous Connect request over the socket
                _socket.ConnectAsync(socketEventArg);

                // Block the UI thread for a maximum of TIMEOUT_MILLISECONDS milliseconds.
                // If no response comes back within this time then proceed
                _clientDone.WaitOne(TIMEOUT_MILLISECONDS);

                return result;
            }

            public string Send(string data)
            {
                string response = "Operation Timeout";

                // We are re-using the _socket object that was initialized in the Connect method
                if (_socket != null)
                {
                    // Create SocketAsyncEventArgs context object
                   SocketAsyncEventArgs socketEventArg = new SocketAsyncEventArgs();

                    // Set properties on context object
                    socketEventArg.RemoteEndPoint = _socket.RemoteEndPoint;
                    socketEventArg.UserToken = null;

                    // Inline event handler for the Completed event.
                    // Note: This event handler was implemented inline in order to make this method self-contained.
                    socketEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(delegate(object s, SocketAsyncEventArgs e)
                    {
                        response = e.SocketError.ToString();

                    
                 
                        // Unblock the UI thread
                        _clientDone.Set();
                    });

                    // Add the data to be sent into the buffer
                    byte[] payload = Encoding.UTF8.GetBytes("A1 LOGIN EMAIL@GMAIL.COM SENHA"+ "\r\n");
                   
                    socketEventArg.SetBuffer(payload, 0, payload.Length);

                    // Sets the state of the event to nonsignaled, causing threads to block
                   _clientDone.Reset();

                    // Make an asynchronous Send request over the socket
                    _socket.SendAsync(socketEventArg);

                            
                    // Block the UI thread for a maximum of TIMEOUT_MILLISECONDS milliseconds.
                    // If no response comes back within this time then proceed
                    _clientDone.WaitOne(TIMEOUT_MILLISECONDS);
                }
                else
                {
                    response = "Socket is not initialized";
                }

                return response;
            }

            public string Receive()
            {
                string response = "Operation Timeout";

                // We are receiving over an established socket connection
                if (_socket != null)
                {
                    // Create SocketAsyncEventArgs context object
                     SocketAsyncEventArgs socketEventArg = new SocketAsyncEventArgs();
                    socketEventArg.RemoteEndPoint = _socket.RemoteEndPoint;


                  

                    // Setup the buffer to receive the data
                    socketEventArg.SetBuffer(new Byte[MAX_BUFFER_SIZE], 0, MAX_BUFFER_SIZE);

                    // Inline event handler for the Completed event.
                    // Note: This even handler was implemented inline in order to make this method self-contained.
                    socketEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(delegate(object s, SocketAsyncEventArgs e)
                    {
                        if (e.SocketError == SocketError.Success)
                        {
                            // Retrieve the data from the buffer
                            //System.Text.Encoding.Unicode.getb
                            byte[] tam = e.Buffer;
                            response = Encoding.UTF8.GetString(tam, 0, tam.Length);
                            response = response.Trim('\0');
                        }
                        else
                        {
                            response = e.SocketError.ToString();
                        }

                        _clientDone.Set();
                    });

                    // Sets the state of the event to nonsignaled, causing threads to block
                    _clientDone.Reset();

                    // Make an asynchronous Receive request over the socket
                    _socket.ReceiveAsync(socketEventArg);

                    // Block the UI thread for a maximum of TIMEOUT_MILLISECONDS milliseconds.
                    // If no response comes back within this time then proceed
                    _clientDone.WaitOne(TIMEOUT_MILLISECONDS);
                }
                else
                {
                    response = "Socket is not initialized";
                }

                return response;
            }

            /// <summary>
            /// Closes the Socket connection and releases all associated resources
            /// </summary>
            public void Close()
            {
                if (_socket != null)
                {
                    _socket.Close();
                }
            }


        }
    }

     

     

     

    terça-feira, 29 de novembro de 2011 14:36