public void RefreshCustomers()
        {
            this.Root.Clear();

            this.Root.Add(new Section("") {
                new StringElement("Refresh", RefreshCustomers)
            });

            var json = NSUserDefaults.StandardUserDefaults.StringForKey("customers");
            if(string.IsNullOrWhiteSpace(json) == false) {
                Customers = JsonSerializer.DeserializeFromString<IEnumerable<Customer>>(json).ToList();
            }

            if(Customers.Any()) {
                var section = new Section("Customers");

                foreach(var customer in Customers) {
                    var desc = string.Format("Customer Name: {0} -- Address: {1}", customer.Name, customer.Address);
                    section.Add(new StringElement(desc));
                }

                this.Root.Add(section);
            }

            using (var pool = new NSAutoreleasePool()) {
                pool.BeginInvokeOnMainThread(()=>{
                    this.ReloadData();
                });
            }
        }

        // This event handler deals with the results of the
        // background operation.
        private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            NSAutoreleasePool pool = new NSAutoreleasePool();

            // First, handle the case where an exception was thrown.
            if (e.Error != null)
            {
                // TODO
            }
            else if (e.Cancelled)
            {
                this.labelResult.StringValue = "Canceled";
            }
            else
            {
                this.labelResult.StringValue = "Fibonacci result for " + this.numberToCompute + " iterations is " + e.Result;
            }

            this.progressIndicator.DoubleValue = 0.0d;

            this.buttonStart.IsEnabled = true;
            this.buttonStop.IsEnabled = false;

            pool.Release();
        }

		// This method is invoked when the application has loaded its UI and its ready to run
		public override bool FinishedLaunching(UIApplication app, NSDictionary options)
		{	
			//HttpDebug.Start (); 

			MonoMobileApplication.NavigationController = new NavigationController();
			MonoMobileApplication.Window = new UIWindow(UIScreen.MainScreen.Bounds);

			MonoMobileApplication.Window.AddSubview(MonoMobileApplication.NavigationController.View);
			MonoMobileApplication.Window.MakeKeyAndVisible();

			MonoMobileApplication.NavigationController.View.Alpha = 0.0f;
	
#if DEBUG
			var thread = new System.Threading.Thread(() =>
			{
				using (NSAutoreleasePool pool = new NSAutoreleasePool())
				{
					InvokeOnMainThread(()=> { Startup(); });
				}
			});
			
			thread.Start();
#else
			InvokeOnMainThread(()=> { Startup(); });
#endif
			return true;
		}

        public static void ShowProgressDialog(string title, string message, Action action, Action finalize) {
            UIAlertView dialog = new UIAlertView(title, message, null, null);

            dialog.Show();
			_indicatorViewLeftCorner.Hidden = false;

            ThreadPool.QueueUserWorkItem(delegate
            {
                // Run the given Async task
                action();

                // Run the completion handler on the UI thread and remove the spinner
                using (var pool = new NSAutoreleasePool())
                {
                    try
                    {
                        pool.InvokeOnMainThread(() =>
                        {
                            dialog.DismissWithClickedButtonIndex(0, true);

							_indicatorViewLeftCorner.Hidden = true;
                            finalize();
                      });
                    }
					catch (Exception ex){
						Insights.Report(ex);
                    }
                }
            });

        }

        /// <summary>
        /// Encodes a frame.
        /// </summary>
        /// <param name="frame">The frame.</param>
        /// <returns></returns>
        public override byte[] Encode(AudioBuffer frame)
		{
			if (_Encoder == null)
			{
				_Encoder = new CocoaOpusEncoder(ClockRate, Channels, PacketTime);
                _Encoder.Quality = 1.0;
                _Encoder.Bitrate = 125;
			}

			using (var pool = new NSAutoreleasePool())
			{
				GCHandle dataHandle = GCHandle.Alloc(frame.Data, GCHandleType.Pinned);
				try
				{
					IntPtr dataPointer = dataHandle.AddrOfPinnedObject();

					using (var buffer = new CocoaOpusBuffer {
						Data = NSData.FromBytesNoCopy(dataPointer, (uint)frame.Data.Length, false),
						Index = frame.Index,
						Length = frame.Length
					})
					{
						using (var encodedFrameData = _Encoder.EncodeBuffer(buffer))
						{
							return encodedFrameData.ToArray();
						}
					}
				}
				finally
				{
					dataHandle.Free();
				}
			}
        }

		private void Startup()
		{
			using (var pool = new NSAutoreleasePool()) 
			{
				InvokeOnMainThread(delegate 
				{
					foreach(var view in MonoMobileApplication.Views)
					{	
						var title = MonoMobileApplication.Title;
						if (view is IView)
							title = ((IView)view).Caption;

						var binding = new BindingContext(view, title);
						MonoMobileApplication.DialogViewControllers.Add(new DialogViewController(UITableViewStyle.Grouped, binding, true) { Autorotate = true } );
					}

					_Navigation.ViewControllers = MonoMobileApplication.DialogViewControllers.ToArray();

					MonoMobileApplication.CurrentDialogViewController = _Navigation.ViewControllers.First() as DialogViewController;

					UIView.BeginAnimations("fadeIn");
					UIView.SetAnimationDuration(0.3f);
					_Navigation.View.Alpha = 1.0f;
					UIView.CommitAnimations();
				});
			}
		}

		public override void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CMSampleBuffer sampleBuffer, AVCaptureConnection connection)
		{
			try {
				connection.VideoOrientation = AVCaptureVideoOrientation.Portrait;

				using (var image = ImageFromSampleBuffer (sampleBuffer)){
					if(_CurrentState.didKnock){
						KnockCount++;

						if(KnockCount==1){
							_CurrentState.CountDown = 5;

							InvokeOnMainThread (delegate {  
								_CurrentState.TopLabel.Text = "Knock Again to Post!!";
								_CurrentState.BottomLabel.Text = "Knock to Post: 5 sec";
							});

						}else if(KnockCount==40){
							_CurrentState.CountDown = 4;
							InvokeOnMainThread (delegate {
								_CurrentState.BottomLabel.Text = "Knock to Post: 4 sec";
							});
						}else if(KnockCount==80){
							_CurrentState.CountDown = 3;
							InvokeOnMainThread (delegate {
								_CurrentState.BottomLabel.Text = "Knock to Post: 3 sec";
							});
						}else if(KnockCount==120){
							_CurrentState.CountDown = 2;
							InvokeOnMainThread (delegate {  
								_CurrentState.BottomLabel.Text = "Knock to Post: 2 sec";
							});
						}else if(KnockCount==160){
							_CurrentState.CountDown = 1;
							InvokeOnMainThread (delegate {  
								_CurrentState.BottomLabel.Text = "Knock to Post: 1 sec";
							});
						}else if(KnockCount>200){
							InvokeOnMainThread (delegate {  
								_CurrentState.TopLabel.Text = "Follow @JoesDoor on Twitter";
								_CurrentState.BottomLabel.Text = "Knock to take a photo";
							});
							KnockCount=0;
							_CurrentState.CountDown = 0;
							_CurrentState.didKnock=false;

						}
					}else{
						InvokeOnMainThread(delegate {
							using (var pool = new NSAutoreleasePool ()) {
								_CurrentState.DisplayImageView.Image = image;
							}
						});
					}
				}
				sampleBuffer.Dispose ();
			} catch (Exception e){
				Console.WriteLine (e);
			}
		}

 public override ICallControl Call(string phoneNumber, CallType type)
 {
     if (CallType.Voice.Equals (type)) {
         using (var pool = new NSAutoreleasePool ()) {
             StringBuilder filteredPhoneNumber = new StringBuilder();
             if (phoneNumber!=null && phoneNumber.Length>0) {
                 foreach (char c in phoneNumber) {
                     if (Char.IsNumber(c) || c == '+' || c == '-' || c == '.') {
                         filteredPhoneNumber.Append(c);
                     }
                 }
             }
             String textURI = "tel:" + filteredPhoneNumber.ToString();
             var thread = new Thread (InitiateCall);
             thread.Start (textURI);
         }
         ;
     } else {
         INotification notificationService = (INotification)IPhoneServiceLocator.GetInstance ().GetService ("notify");
         if (notificationService != null) {
             notificationService.StartNotifyAlert ("Phone Alert", "The requested call type is not enabled or supported on this device.", "OK");
         }
     }
     return null;
 }

        public Game(float width, float height)
            : base(width, height)
        {
            using (NSAutoreleasePool pool = new NSAutoreleasePool ())
            {
                AddChild (SPImage.ImageWithContentsOfFile ("Default.png"));

                mMainMenu = new SPSprite();
                AddChild (mMainMenu);

                mMainMenu.AddChild (SPImage.ImageWithContentsOfFile ("logo.png"));

                SPTexture sceneButtonTexture = SPTexture.TextureWithContentsOfFile ("button_big.png");

                atlasButton = SPButton.ButtonWithUpState (sceneButtonTexture, "Texture Atlas");
                atlasButton.AddEventListener (onAtlasButtonTriggered, SPEvents.ButtonTriggered);
                addSceneButton (atlasButton);

                SPTexture backButtonTexture = SPTexture.TextureWithContentsOfFile ("button_back.png");
                mBackButton = new SPButton (backButtonTexture, "back");
                mBackButton.Visible = false;
                mBackButton.X = (int)(Stage.Width - mBackButton.Width) / 2;
                mBackButton.Y = Stage.Height - mBackButton.Height + 1;
                mBackButton.AddEventListener (onBackButtonTriggered, SPEvents.ButtonTriggered);
                AddChild (mBackButton);

            //			SPJuggler jug = this.Stage.Juggler;
            //			jug.DelayInvocationAtTarget (this, 5.0).PerformSelector (new Selector ("onAtlasButtonTriggered:"), null, 0);
            }
        }

// Uncomment to demonstrate UIActiviyIndicatorView
//        void HandleShowActivityButtonTouchUpInside (object sender, EventArgs e)
//        {
//            _activityView = new UIActivityIndicatorView ();
//            
//            _activityView.Frame = new RectangleF (0, 0, 50, 50);
//            _activityView.Center = View.Center;
//            
//            _activityView.ActivityIndicatorViewStyle = UIActivityIndicatorViewStyle.WhiteLarge;
//            View.AddSubview (_activityView);
//            _activityView.StartAnimating ();
//            
//            Thread t = new Thread (DoSomething);
//            t.Start ();
//        }

        void DoSomething ()
        {
            Thread.Sleep (3000);
            
            using (var pool = new NSAutoreleasePool ()) {
                this.InvokeOnMainThread (delegate { _activityView.StopAnimating (); });
            }
        }

        private static void Run()
        {
            NSAutoreleasePool pool = new NSAutoreleasePool ();

            Console.WriteLine ("Hello World !!!");

            pool.Release ();
        }

		/// <summary>
		/// Populates a <see cref="T:System.Runtime.Serialization.SerializationInfo"/> with the data needed to serialize the target object.
		/// </summary>
		/// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
		/// <param name="context">The destination (see <see cref="T:System.Runtime.Serialization.StreamingContext"/>) for this serialization.</param>
		/// <exception cref="T:System.Security.SecurityException">
		/// The caller does not have the required permission.
		/// </exception>
		public void GetObjectData (SerializationInfo info, StreamingContext context)
		{
			// As pool are scoped, it does not hurt if we create ours during the method call.
			using (NSAutoreleasePool pool = new NSAutoreleasePool()) {
				NSData data = this.TIFFRepresentation;
				info.AddValue ("Data", data.GetBuffer (), typeof(byte[]));
			}
		}

 public void HideSearchingView()
 {
     using(var pool = new NSAutoreleasePool()) {
         pool.BeginInvokeOnMainThread(() => {
             IsSearching = false;
             _SearchingView.Hidden = true;
         });
     }
 }

		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		static void Main (string[] args)
		{
			NSApplication.Init ();

			using (var p = new NSAutoreleasePool ()) {
				NSApplication.SharedApplication.Delegate = new AppDelegate ();
				NSApplication.Main (args);
			}
		}

 public override bool SetRequestInterval(double intervalInSeconds)
 {
     using (var pool = new NSAutoreleasePool ()) {
         Thread thread = new Thread (SetRequestIntervalThread);
         thread.Priority = ThreadPriority.AboveNormal;
         thread.Start ((object)intervalInSeconds);
     }
     return true;
 }

		private void Startup ()
		{
			using (var pool = new NSAutoreleasePool ()) {
				InvokeOnMainThread (delegate {
					var binding = new BindingContext (new MovieListView (), "Movie List View");
					navigation.ViewControllers = new UIViewController[] { new DialogViewController (binding.Root, true) };
				});
			}
		}

        // This event handler updates the progress bar.
        private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            NSAutoreleasePool pool = new NSAutoreleasePool();

            this.progressIndicator.DoubleValue = e.ProgressPercentage;
            this.labelResult.StringValue = "Progress is " + e.ProgressPercentage + "%";

            pool.Release();
        }

        protected override void HandleThreadMethod()
        {
            using(var pool = new NSAutoreleasePool())
            {
                // Run code in new thread
                clientInfo.BeginReceive();

            }
        }

 public void Start()
 {
     using(var pool = new NSAutoreleasePool())
     {
         ThreadStart threadDelegate = new ThreadStart (HandleThreadMethod);
         Thread thread = new Thread (threadDelegate);
         thread.Start ();
     }
 }

 public override bool DownloadFile(string url)
 {
     using (var pool = new NSAutoreleasePool ()) {
         NSUrl urlParam = new NSUrl (Uri.EscapeUriString(url));
         var thread = new Thread (OpenUrlOnThread);
         thread.Start (urlParam);
     }
     return true;
 }