示例#1
0
        private void OnWork(JSValue[] arguments)
        {
            // Must be a function object.
            if (!arguments[0].IsFunctionObject)
            {
                return;
            }

            // You can cache this callback and call it only when your application
            // has performed all work necessary and has a result ready to send.
            // Note that this callback object is valid for as long as the current
            // page is loaded. A navigation will invalidate it.
            JSFunction callbackArg = arguments[0];

            // Make sure it's a function object.
            if (!callbackArg)
            {
                return;
            }

            // See it!
            Debug.Print(callbackArg.ToString());

            // You need to copy the object if you intend to cache it. The original
            // object argument passed to the handler is destroyed by default when
            // the handler returns. A copy will keep it alive. Note that the clone
            // of a JSFunction, will definitely be a JSFunction as well.
            JSFunction callback = (JSFunction)callbackArg.Clone();

            // Perform your heavy work.
            Task.Factory.StartNew(
                (Func <object, string>)PerformWork, callback).ContinueWith(
                /* Send a response when complete. */
                SendResponse,

                /* Make sure the response is sent on the
                 * initial thread. */
                TaskScheduler.FromCurrentSynchronizationContext());
        }
        // Handler of the external.app.performHeavyWork method.
        private void OnWork(object sender, JavascriptMethodEventArgs e)
        {
            // Must have 2 arguments passed.
            if (e.Arguments.Length != 3)
            {
                return;
            }

            // Must be a function object.
            if (!e.Arguments[0].IsFunctionObject)
            {
                return;
            }

            // Must be a timeout value.
            if (!e.Arguments[1].IsNumber)
            {
                return;
            }

            // Must be the image id.
            if (!e.Arguments[2].IsNumber)
            {
                return;
            }

            // Get the NavigationInterceptor. This will allow us to cancel the operation
            // if the user navigates away.
            INavigationInterceptor navigationInterceptor = webControl.GetService(typeof(INavigationInterceptor)) as INavigationInterceptor;

            // Without this, do not proceed.
            if (navigationInterceptor == null)
            {
                return;
            }

            // You can cache the callback and call it only when your application
            // has performed all work necessary and has a result ready to send.
            // Note that this callback object is valid for as long as the current
            // page is loaded; a navigation will invalidate it. This is why we
            // need the NavigationInterceptor service acquired above.
            JSFunction callbackArg = e.Arguments[0];
            // Get the image id.
            int id = (int)e.Arguments[1];
            // Get the timeout specified.
            int timeout = (int)e.Arguments[2];

            // Make sure it's a function object.
            if (!callbackArg)
            {
                return;
            }

            // See it!
            Debug.Print(callbackArg.ToString());

            // You need to copy the object if you intend to cache it. The original
            // object argument passed to the handler is destroyed by default when
            // the handler returns. A copy will keep it alive. Note that the clone
            // of a JSFunction, will definitely be a JSFunction as well.
            JSFunction callback = (JSFunction)callbackArg.Clone();

            // Create a state object. This holds the callback and controls
            // cancellation. It is passed to both the background operation procedure
            // and the response procedure.
            JavascriptCallbackState state = new JavascriptCallbackState(navigationInterceptor, callback, id, timeout);

            // Perform your heavy work.
            Task.Factory.StartNew(
                /* The function that will perform the work. */
                (Func <Object, String>)PerformWork,
                /* Pass the state object. */
                state,

                /* The CancellationToken that will let us know if we
                 * should cancel passing back the result. */
                state.Token).ContinueWith(
                /* Send the result when complete. */
                SendResponse,

                /* Make sure the result is sent on the
                 * initial thread. */
                TaskScheduler.FromCurrentSynchronizationContext());
        }