//淡入
 public void FadeIn(float _fadeInTime, CallBack _fun = null)
 {
     if (!isFading)
     {
         StartCoroutine(FadeAction(true,_fadeInTime, _fun));
     }
 }

        public static void Main()
        {
            CallBack callback = new CallBack(TimeNow);
            Timer time = new Timer(callback.Invoke, null, 0, 1000);

            Console.Read(); //press enter to exit
        }

 //淡出
 public void FadeOut(float _fadeOutTime, CallBack _fun = null)
 {
     if (!isFading)
     {
         StartCoroutine(FadeAction(false,_fadeOutTime, _fun));
     }
 }

        public void AddVkFriend(string uid, CallBack onSuccess, CallBack onError)
        {
            if (!this.connected)
            {
                return;
            }

            var url = "https://api.vk.com/method/friends.add";
            var sendData = new Dictionary<string, string>
                               {
                                   { "access_token", this.access_token },
                                   { "uid", uid }
                               };
            this.GetQuery(
                url,
                sendData,
                res =>
                    {
                        var decodedResponse = Newtonsoft.Json.Linq.JObject.Parse(res.ToString());
                        var answer = decodedResponse["response"];
                        if (answer == null)
                        {
                            onError(new object());
                            return;
                        }

                        onSuccess(answer.ToString());
                    },
                res =>
                    {
                        onError(new object());
                    });
        }

 //从淡入到淡出
 public void FadeInToOut(float _fadeInTime, float afterInDelayTime, float _fadeOutTime, CallBack afterFadeInCallback=null, CallBack afterFadeOutCallback = null)
 {
     if (!isFading)
     {
         StartCoroutine(FadeInToOutAction(_fadeInTime, afterInDelayTime, _fadeOutTime, afterFadeInCallback, afterFadeOutCallback));
     }
 }

        public void Handle(List<UPnPArg> args, CallBack cb, XMLWriterPi writer)
        {
            Console.WriteLine("Browse Was called (BrowseStrat)");
            List<UPnPArg> retArgs = new List<UPnPArg>();

            string containerId = GetContainerID(args);

            if (containerId == "BadArgs")
            {
                cb(retArgs, containerId);
            }
            else
            {
                List<ITrack> containingList = _dbLookup.Browse(containerId);
                int NumberReturned = containingList.Count;

                string retVal = writer.ConvertITrackToXML(containingList);

                retArgs.Add(new UPnPArg("Result", retVal));
                retArgs.Add(new UPnPArg("NumberReturned", NumberReturned.ToString()));
                retArgs.Add(new UPnPArg("TotalMatches", NumberReturned.ToString()));

                cb(retArgs, "Browse");
            }
        }

 public void registerCallBack(CallBack callbackToRegister)
 {
     if(!m_Listeners.Contains(callbackToRegister))
     {
         m_Listeners.Add(callbackToRegister);
     }
 }

 public void addEventListner(string eventType,CallBack function)
 {
     if(_listenList==null){
         _listenList		= new List<EventListenTerm>();
     }
     _listenList.Add(new EventListenTerm(eventType,function));
 }

 public void removeCallBack(CallBack callbackToRemove)
 {
     if (m_Listeners.Contains(callbackToRemove))
     {
         m_Listeners.Remove(callbackToRemove);
     }
 }

 public void string_callback(CallBack cb, [StringValue][WideChar(false)] string mesg) {
     if(cb == null) {
         Console.WriteLine("Received a nil callback.");
         return;
     }              
     cb.call_back(mesg);
 }

 //passing the delegate as a parameter
 // declaring the delegate
 public void LongForLoop(CallBack obj)
 {
     for (int i = 0; i < 10000; i++)
     {
         obj(i); //invokeing the delegate
     }
 }

    public static void Request(MethodType method, string uri, string body, CallBack<string> callBack)
    {
        try
        {
            Init("8aa5b8b5-f769-11e3-954e-06a6fa0000b9", "6ef2e5c0-3ef1-11e4-ae91-06a6fa0000b9");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(APIEndpoint + uri);

            request.Method = method.ToString();
            request.ContentType = "applications/json";

            if (PlayerPrefs.HasKey("access_token"))
            request.Headers["Authorization"] = "Bearer " + PlayerPrefs.GetString("access_token");

            if(request.Method == "POST" || request.Method == "PUT")
            {
                StreamWriter writer = new StreamWriter(request.GetRequestStream());
                writer.Write(body);
                writer.Close();
            }

            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            Stream dataStream = response.GetResponseStream();
            StreamReader reader = new StreamReader(dataStream);

            string responseFromServer = reader.ReadToEnd();

            callBack(responseFromServer);
        }
        catch(Exception e)
        {
            Debug.Log(e.Message);
        }
    }

    IEnumerator FadeAction(bool isFadeIn,float tempFadeTime,  CallBack _fun)
    {
        tempColor = GUI.color;
        GUI.depth = 100;
        fadeTime = tempFadeTime;

        if (isFadeIn) alpha = 0;
        else alpha = 1;

        if (crossfadeTexture == null)
        {
            crossfadeTexture = new Texture2D(1, 1, TextureFormat.RGB24, false);
            crossfadeTexture.SetPixel(0, 0, Color.black);
            crossfadeTexture.Apply();
        }

        isFading = true;
        float tempTime = fadeTime + Time.unscaledTime; ;

        while (true)
        {
                if (!isFadeIn)
                {
                    alpha = (tempTime - Time.unscaledTime) / fadeTime;

                    if (alpha < 0.05f)
                    {
                        alpha = 0;
                        break;
                    }
                }
                else
                {
                    alpha = Mathf.Clamp(1 - ((tempTime - Time.unscaledTime) / fadeTime), 0f, 1f);

                    if (alpha >= 0.98f)
                    {
                        alpha = 1;
                        break;
                    }
                }
            yield return new WaitForEndOfFrame();
        }
        yield return new WaitForEndOfFrame();
        isFading = false;
        Debug.Log("Camera fade alpha: " + alpha);
        try
        {
            if (_fun != null)
            {
                _fun();
            }
        }
        catch (Exception e)
        {
            Debug.LogError("Camera Fade Call back Exception :" + e);
        }
          //  yield return new WaitForEndOfFrame();
    }

 public void onShowDCN(string mess, CallBack clickOK) {
     DoOnMainThread.ExecuteOnMainThread.Enqueue(() => {
         this.lb_mess.text = mess;
         btnOK.gameObject.SetActive(true);
         onClickOK = clickOK;
         onShow();
     });
 }

        public static void Main(string[] args)
        {
            // Create an instance of the delegate
            CallBack myCallBack = new CallBack(Program.Report);

            // Call the function
            EnumWindows(myCallBack, 0);
        }

 public void RequestInventory(string accountID, CallBack callBack)
 {
     string url = host + "getInventory";
     WWWForm form = new WWWForm();
     form.AddField("PlayerId", accountID.ToString());
     WWW www = new WWW(url, form);
     StartCoroutine(WaitForRequest(www, callBack));
 }

 public CKLBUICanvas(CKLBUITask parent, uint order, float x, float y, uint vertexMax, uint indexMax, CallBack onDrawCallBack)
     : base(s_classID)
 {
     NativeManagement.resetCppError();
     IntPtr ptr = CKLBUICanvas_create(parent != null ? parent.CppObject : IntPtr.Zero, order, x, y, vertexMax, indexMax);
     NativeManagement.intercepCppError();
     bind(ptr);
     m_callback = onDrawCallBack;
 }

 public CKLBStoreService(CallBack callback)
     : base(s_classID)
 {
     NativeManagement.resetCppError();
     IntPtr ptr = CKLBStoreService_create();
     NativeManagement.intercepCppError();
     m_callback = callback;
     bind(ptr);
 }

 public CKLBUITouchPad(CKLBTask parent, CallBack callback, bool modal = false)
     : base(s_classID)
 {
     NativeManagement.resetCppError();
     IntPtr ptr = CKLBUITouchPad_create(parent != null ? parent.CppObject : IntPtr.Zero, modal);
     NativeManagement.intercepCppError();
     bind(ptr);
     m_callback = callback;
 }

 //a string is given to the constructor which creates a font object
 public CKLBUIDebugItem(CKLBUITask parent, uint order, float x, float y, uint argb, String font_name, uint font_size, String text, uint cmdID, CallBack callback)
     : base(s_classID)
 {
     NativeManagement.resetCppError();
     IntPtr ptr = CKLBUIDebugItem_create(parent != null ? parent.CppObject : IntPtr.Zero, order, x, y, argb, __MarshallingUtils.NativeUtf8FromString(font_name), font_size, __MarshallingUtils.NativeUtf8FromString(text), cmdID);
     NativeManagement.intercepCppError();
     bind(ptr);
     m_callback = callback;
 }