Пример #1
0
        public void GetVideoThumbnail(string videoUrl, RequestComplete resultHandler)
        {
            // get the video's ID
            string videoId = videoUrl.Substring(videoUrl.LastIndexOf("/") + 1);

            videoId = videoId.Substring(0, videoId.IndexOf("."));

            // get the metadata for this video, which will contain the thumbnail url
            RestRequest request = new RestRequest(Method.GET);

            request.RequestFormat = DataFormat.Xml;

            string requestUrl = string.Format("https://vimeo.com/api/v2/video/{0}.xml", videoId);

            HttpRequest.ExecuteAsync <VimeoVideo>(requestUrl, request, delegate(System.Net.HttpStatusCode statusCode, string statusDescription, VimeoVideo model)
            {
                if (Rock.Mobile.Network.Util.StatusInSuccessRange(statusCode) == true)
                {
                    RequestThumbnail(model.ThumbnailLarge, resultHandler);
                }
                else
                {
                    resultHandler(statusCode, statusDescription, null);
                }
            });
        }
Пример #2
0
        public static IEnumerator RequestByWWW(string url, RequestComplete loadComplete)
        {
            if (string.IsNullOrEmpty(url))
            {
                Debug.LogError("RequestAssetByWWW url is null or empty. ");
                yield break;
            }
            using (WWW www = new WWW(url))
            {
                yield return(www);

                try
                {
                    if (www.isDone && string.IsNullOrEmpty(www.error))
                    {
                        loadComplete(www);
                    }
                    else
                    {
                        Debug.LogErrorFormat("LoadAssetByWWW load '{0}'.error '{1}'. ", url, www.error);
                        loadComplete(null, www.error);
                    }
                }
                catch (Exception e)
                {
                    Debug.LogErrorFormat("LoadAssetByWWW '{0}' error '{1}', {2}. ", url, e.Message, e.StackTrace);
                }
                finally
                {
                    www.Dispose();
                }
            }
        }
Пример #3
0
        /// <summary>
        /// 人脸识别
        /// </summary>
        /// <param name="img"></param>
        /// <param name="complete"></param>
        /// <returns></returns>
        public IEnumerator PostDetect(byte[] img, RequestComplete complete)
        {
            WWWForm wwwForm = new WWWForm();

            wwwForm.AddField("api_key", Utility.Http.EscapeString("api-key"));
            wwwForm.AddField("api_secret", Utility.Http.EscapeString("api-secret"));
            wwwForm.AddField("return_attributes", "emotion"); // int  string 类型  详情参数查看 https://console.faceplusplus.com.cn/documents/4888373
            wwwForm.AddBinaryData("image_file", img);         // 二进制  类型

            yield return(UtilityMisc.RequestByWWW(FaceppV3Detect, wwwForm, complete));
        }
Пример #4
0
        /// <summary>
        /// Called to read the response asyncroneusly
        /// </summary>
        /// <param name="ar"></param>
        private void ReadResponse(IAsyncResult ar)
        {
            Stream           stream    = null;
            int              bytesRead = 0;
            HttpClientResult result    = HttpClientResult.Error;

            try
            {
                lock (_lock)
                {
                    stream    = (Stream)ar.AsyncState;
                    bytesRead = stream.EndRead(ar);

                    if (bytesRead > 0)
                    {
                        //add to the exiting data
                        _dataBuilder.AddChunkReference(_buffer, bytesRead);
                        //make a new chunk
                        _buffer = new byte[MAX_BUFFER_SIZE];
                        //continue reading
                        stream.BeginRead(_buffer, 0, MAX_BUFFER_SIZE, new AsyncCallback(ReadResponse), stream);
                    }
                    else
                    {
                        //construct the full response
                        _response = _dataBuilder.ToArray();
                        result    = HttpClientResult.Success;
                    }
                }
            }
            catch
            {
                //we don't care that much for the errors that occur here
            }
            finally
            {
                if (bytesRead == 0)
                {
                    //if the caller was waiting on the request complete event allow continuation
                    _requestCompleteEvent.Set();

                    //we're done reading close the connection and trigger the event with the collected response
                    //the result will be success
                    if (RequestComplete != null)
                    {
                        RequestComplete.Invoke
                            (new HttpClientRequestCompleteEventArgs(new HttpResponseInfo(_response)));
                    }
                    _connection.Close();
                }
            }
        }
Пример #5
0
        void RequestThumbnail(string thumbnailUrl, RequestComplete resultHandler)
        {
            // grab the actual image
            RestRequest request = new RestRequest(Method.GET);

            // get the raw response
            HttpRequest.ExecuteAsync(thumbnailUrl, request, delegate(System.Net.HttpStatusCode statusCode, string statusDescription, byte[] model)
            {
                if (Rock.Mobile.Network.Util.StatusInSuccessRange(statusCode) == true)
                {
                    MemoryStream memoryStream = new MemoryStream(model);

                    resultHandler(statusCode, statusDescription, memoryStream);

                    memoryStream.Dispose( );
                }
                else
                {
                    resultHandler(statusCode, statusDescription, null);
                }
            });
        }
Пример #6
0
 // This gets called after failure or success
 protected void OnRequestComplete()
 {
     RequestComplete?.Invoke(this, null);
 }
Пример #7
0
 public void SetServiceCallbacks(ServiceRequestComplete serviceRequestComplete, RequestComplete requestComplete)
 {
     OnServiceDetailRequestComplete = null;
     OnServiceRequestComplete = null;
     OnServiceRequestComplete = serviceRequestComplete;
     OnRequestError = requestComplete;
 }
Пример #8
0
        public void SetMapEvents(RequestComplete requestComplete, RequestComplete requestError, RequestComplete requestIdentifyComplete)
        {
            OnMapRequestComplete = OnRequestError = OnIdentifyRequestComplete = null;

            OnMapRequestComplete += requestComplete;
            OnRequestError += requestError;
            OnIdentifyRequestComplete += requestIdentifyComplete;
        }
Пример #9
0
 public void SetSearchCallback(RequestComplete onRequestComplete, RequestComplete onRequestError)
 {
     OnSearchRequestComplete = null;
     OnSearchRequestComplete += onRequestComplete;
     OnRequestError += onRequestError;
 }
Пример #10
0
        /// <summary>
        /// Sends the specified request to the server
        /// (Proxy not supported)
        /// </summary>
        /// <param name="parsedRequest"></param>
        /// <param name="host"></param>
        /// <param name="port"></param>
        /// <param name="https"></param>
        public void SendRequest(HttpRequestInfo parsedRequest, string host, int port, bool https)
        {
            _requestCompleteEvent.Reset();

            _dataBuilder = new ByteArrayBuilder();

            if (_connection == null)
            {
                _connection = new HttpClientConnection(host, port, https);
            }

            try
            {
                //connect
                if (_connection.Connect())
                {
                    bool isProxy = _connection.Host != host;

                    //add connection closed header only this is supported at the moment
                    parsedRequest.Headers["Connection"] = "close";

                    if (isProxy)
                    {
                        parsedRequest.Headers["Proxy-Connection"] = "close";
                    }

                    // Turn off accepting of gzip/deflate
                    //parsedRequest.Headers.Remove("Accept-Encoding");

                    //calculate the content length
                    if (parsedRequest.ContentData != null)
                    {
                        parsedRequest.Headers["Content-Length"] = parsedRequest.ContentData.Length.ToString();
                    }

                    parsedRequest.Host     = host;
                    parsedRequest.Port     = port;
                    parsedRequest.IsSecure = https;

                    if (isProxy && https)
                    {
                        //send a connect message to the proxy
                        SendConnect(host, port);
                    }

                    byte[] reqBytes = Constants.DefaultEncoding.GetBytes(parsedRequest.ToString(isProxy && !https));

                    //write to the stream
                    _connection.Stream.Write(reqBytes, 0, reqBytes.Length);

                    //start reading
                    _buffer = new byte[MAX_BUFFER_SIZE];
                    _connection.Stream.BeginRead(_buffer, 0, MAX_BUFFER_SIZE, new AsyncCallback(ReadResponse), _connection.Stream);
                }
                else
                {
                    throw new Exception("Cannot connect to server");
                }
            }
            catch (Exception ex)
            {
                SdkSettings.Instance.Logger.Log(TraceLevel.Error, "HttpClient error sending request {0}", ex.Message);
                //notify the caller that the request was completed with an error
                if (RequestComplete != null)
                {
                    RequestComplete.Invoke(
                        new HttpClientRequestCompleteEventArgs());
                    RequestCompleteEvent.Set();
                }

                _connection.Close();
            }
        }
        public static void MakeRequest(string verb, string requestUrl, string obj, RequestComplete handle)
        {
            WebRequest request = WebRequest.Create(requestUrl);

            request.Method = verb;
            string respstring = String.Empty;

            using (MemoryStream buffer = new MemoryStream())
            {
                if ((verb == "POST") || (verb == "PUT"))
                {
                    request.ContentType = "text/www-form-urlencoded";

                    int length = 0;
                    using (StreamWriter writer = new StreamWriter(buffer))
                    {
                        writer.Write(obj);
                        writer.Flush();
                    }

                    length = obj.Length;
                    request.ContentLength = length;

                    try
                    {
                        request.BeginGetRequestStream(delegate(IAsyncResult res)
                        {
                            Stream requestStream = request.EndGetRequestStream(res);

                            requestStream.Write(buffer.ToArray(), 0, length);
                            requestStream.Close();
                        }, null);
                    }
                    catch (Exception e)
                    {
                        MainConsole.Instance.DebugFormat("[FORMS]: exception occured on sending request to {0}: " + e, requestUrl);
                        return;
                    }
                    finally
                    {
                    }

                    WebResponse response = null;
                    request.BeginGetResponse(delegate(IAsyncResult res2)
                    {
                        try
                        {
                            // If the server returns a 404, this appears to trigger a System.Net.WebException even though that isn't
                            // documented in MSDN
                            response = request.EndGetResponse(res2);

                            Stream respStream = null;
                            try
                            {
                                respStream = response.GetResponseStream();
                                if (respStream != null)
                                {
                                    using (StreamReader reader = new StreamReader(respStream))
                                    {
                                        respstring = reader.ReadToEnd();
                                    }
                                }
                            }
                            catch (InvalidOperationException)
                            {
                            }
                            finally
                            {
                                if (respStream != null)
                                {
                                    respStream.Close();
                                }
                                response.Close();
                            }
                            handle(respstring);
                        }
                        catch (WebException e)
                        {
                            if (e.Status == WebExceptionStatus.ProtocolError)
                            {
                                if (e.Response is HttpWebResponse)
                                {
                                    HttpWebResponse httpResponse =
                                        (HttpWebResponse)e.Response;

                                    if (httpResponse.StatusCode != HttpStatusCode.NotFound)
                                    {
                                        // We don't appear to be handling any other status codes, so log these feailures to that
                                        // people don't spend unnecessary hours hunting phantom bugs.
                                        MainConsole.Instance.DebugFormat(
                                            "[ASYNC REQUEST]: Request {0} {1} failed with unexpected status code {2}",
                                            verb, requestUrl, httpResponse.StatusCode);
                                    }
                                }
                            }
                            else
                            {
                                MainConsole.Instance.ErrorFormat(
                                    "[ASYNC REQUEST]: Request {0} {1} failed with status {2} and message {3}",
                                    verb, requestUrl, e.Status, e);
                            }
                        }
                        catch (Exception e)
                        {
                            MainConsole.Instance.ErrorFormat(
                                "[ASYNC REQUEST]: Request {0} {1} failed with exception {2}",
                                verb, requestUrl, e);
                        }
                    }, null);
                }
            }
        }
Пример #12
0
 public void SetRequestCompleteCallBack(RequestComplete callback)
 {
     requestComplete = callback;
 }
Пример #13
0
 /// <summary>
 /// Request complete invoker
 /// </summary>
 protected void OnRequestComplete(Guid id, LogInfo requestLog, LogInfo responseLog)
 {
     RequestComplete?.Invoke(this, new RequestEventArgs(id, requestLog, responseLog));
 }
Пример #14
0
        public void GetVideoThumbnail( string videoUrl, RequestComplete resultHandler )
        {
            // get the video's ID
            string videoId = videoUrl.Substring( videoUrl.LastIndexOf( "/" ) + 1 );
            videoId = videoId.Substring( 0, videoId.IndexOf( "." ) );

            // get the metadata for this video, which will contain the thumbnail url
            RestRequest request = new RestRequest( Method.GET );
            request.RequestFormat = DataFormat.Xml;

            string requestUrl = string.Format( "http://vimeo.com/api/v2/video/{0}.xml", videoId );
            HttpRequest.ExecuteAsync<VimeoVideo>( requestUrl, request, delegate(System.Net.HttpStatusCode statusCode, string statusDescription, VimeoVideo model) 
                {
                    if( Rock.Mobile.Network.Util.StatusInSuccessRange( statusCode ) == true )
                    {
                        RequestThumbnail( model.ThumbnailLarge, resultHandler );
                    }
                    else
                    {
                        resultHandler( statusCode, statusDescription, null );
                    }
                } );
        }
Пример #15
0
        void RequestThumbnail( string thumbnailUrl, RequestComplete resultHandler )
        {
            // grab the actual image
            RestRequest request = new RestRequest( Method.GET );
                        
            // get the raw response
            HttpRequest.ExecuteAsync( thumbnailUrl, request, delegate(System.Net.HttpStatusCode statusCode, string statusDescription, byte[] model )
                {
                    if ( Rock.Mobile.Network.Util.StatusInSuccessRange( statusCode ) == true )
                    {
                        MemoryStream memoryStream = new MemoryStream( model );

                        resultHandler( statusCode, statusDescription, memoryStream );

                        memoryStream.Dispose( );
                    }
                    else
                    {
                        resultHandler( statusCode, statusDescription, null );
                    }
                } );
        }