protected Player (Parcel inObj)
		{
			FirstName = inObj.ReadString ();
			LastInitial = inObj.ReadString ();
			// TODO: something strange
			Avatar = (Avatar)Enum.GetValues (typeof(Avatar)).GetValue (inObj.ReadInt ());
		}

 /// <summary>
 /// IParcelable member
 /// </summary>
 /// <param name="dest"></param>
 /// <param name="flags"></param>
 public void WriteToParcel(Parcel dest, [GeneratedEnum] ParcelableWriteFlags flags)
 {
     dest.WriteString(this.DateOfIssue.ToString());
     dest.WriteString(this.Id.ToString());
     dest.WriteString(this.AdditionalInfo);
     dest.WriteString(this.PhoneNumber);
 }

        public Receipt(Parcel parcelable)
        {
            Type receipType = JsonConvert.DeserializeObject<Type>(parcelable.ReadString());

            var receiptString = parcelable.ReadString();
            receipt = JsonConvert.DeserializeObject(receiptString, receipType) as ITransactionResult;
        }

        public byte[] ToParcel()
        {
            var p = new Parcel();
            p.AddLengthString16(PackageName);
            p.AddLengthString16(ProcessName);
            p.AddLengthString16(TaskAffinity);
            p.AddLengthInt32(uid);
            p.AddLengthInt32(flags);
            p.AddLengthString16(SourceDir);
            p.AddLengthString16(PublicSourceDir);
            p.AddLengthString16(DataDir);
            p.AddLengthInt32(Enabled ? 1 : 0);
            p.AddLengthInt32(TargetSdkVersion);
            p.AddLengthString16(Intent);

            p.AllocateBuffer();

            p.WriteString16(PackageName);
            p.WriteString16(ProcessName);
            p.WriteString16(TaskAffinity);
            p.WriteInt32(uid);
            p.WriteInt32(flags);
            p.WriteString16(SourceDir);
            p.WriteString16(PublicSourceDir);
            p.WriteString16(DataDir);
            p.WriteInt32(Enabled ? 1 : 0);
            p.WriteInt32(TargetSdkVersion);
            p.WriteString16(Intent);
            return p.Buffer;
        }

		public void WriteToParcel (Parcel dest, ParcelableWriteFlags flags)
		{
			dest.WriteInt(this.Id_libro);
			dest.WriteString(this.Nombre);
			dest.WriteString(this.Autor);
			dest.WriteInt(this.Total_pag);
			dest.WriteString(this.Descripcion);
		}

 public CardToken(Parcel parcel)
 {
     CardLastFour = parcel.ReadString();
     ExpiryDate = parcel.ReadString();
     Token = parcel.ReadString();
     CardType = (CardBase.CardType)parcel.ReadInt();
     ConsumerToken = parcel.ReadString();
 }

	public void ResetCycle(Parcel thisParcel, Plant plant){
		ResetParcel(thisParcel);

		GameObject newPlant = Instantiate(GameModel.Instance.plantPrefab) as GameObject;
		thisParcel.mesh = GameModel.Instance.seedling;
		newPlant.transform.SetParent(thisParcel.transform, false);
		newPlant.GetComponent<PlantPrefab>().plant = plant;
	}

 public MetaData(Parcel inParcel)
 {
     //There is a string in the parcel
     if (inParcel.ReadInt() > 0)
     {
         Metadata = JsonConvert.DeserializeObject<Dictionary<string, string>>(inParcel.ReadString());
     }
 }

			Java.Lang.Object IParcelableCreator.CreateFromParcel(Parcel source)
			{
				int id = source.ReadInt ();
				string nombre = source.ReadString();
				string autor = source.ReadString();
				int total_pag = source.ReadInt ();
				string descripcion = source.ReadString();
				return new cls_Libro(id,nombre,autor,total_pag,descripcion);
			}

		public void WriteToParcel (Parcel dest, ParcelableWriteFlags flags)
		{
			dest.WriteDouble (_User.Height);
			dest.WriteDouble (_User.Weight);
			dest.WriteDouble (_User.CigPerDay);
			dest.WriteDouble (_User.HrsSleep);
			dest.WriteString (_User.Sex.ToString ());
			dest.WriteString (_User.BirthDate.ToString ());
		}

        public override string Handle(Parcel parcel)
        {
            if (parcel.IsInsured)
            {
                return "DELUXE: " +
                       "Take special care of package at a whooping price.";
            }

            return NextHandler.Handle(parcel);
        }

        public override string Handle(Parcel parcel)
        {
            if (parcel.Value >= 50m && !parcel.IsInsured)
            {
                return "NORMAL: " +
                       "Deliver package at a reasonable price";
            }

            return NextHandler.Handle(parcel);
        }

        public override string Handle(Parcel parcel)
        {
            if (parcel.Value < 50m && !parcel.IsInsured)
            {
                return "BUDGET: " +
                       "Assault package at a discount price";
            }

            return NextHandler.Handle(parcel);
        }

		protected Category (Parcel inObj)
		{
			Name = inObj.ReadString ();
			Id = inObj.ReadString ();
			//TODO
//			Theme = (Theme)System.Enum.GetValues ()inObj.ReadInt ();
			Quizzes = new List<Quiz> ();
			inObj.ReadTypedList (Quizzes, Quiz.InitializeCreator ());
			Scores = inObj.CreateIntArray ();
			Solved = ParcelableHelper.ReadBoolean (inObj);
		}

        public void SendsTheBoxedOrderByMail()
        {
            var order = new Order { Address = "bbv Software Serivces AG; Luzern" };
            order.Positions.Add(new Position { Item = "Visual Studio", Amount = 3 });
            order.Positions.Add(new Position { Item = "ReSharper", Amount = 2 });

            var parcel = new Parcel();
            A.CallTo(() => this.boxingService.Box(order)).Returns(parcel);

            this.testee.Deliver(order);

            A.CallTo(() => this.mailService.Deliver(order.Address, parcel)).MustHaveHappened();
        }

     public void WriteToParcel(Parcel dest, ParcelableWriteFlags flags)
     {
         if (Metadata != null)
         {
             var metaDataString = JsonConvert.SerializeObject(Metadata);
 
             dest.WriteInt(metaDataString.Length);
             dest.WriteString(metaDataString);
         }
         else
         {
             dest.WriteInt(0);
         }
         
     }

		public async Task<List<Tariff>> Estimate(Parcel parcel, DeliveryOptions deliveryOptionsoptions, CancellationToken ct)
		{
			await _browser.ExecuteJs(JsCode, ct);
			var tariffs = new List<Tariff>();

			var deliveryPath = await SetDeliveryPath(parcel, ct);
			if (string.IsNullOrWhiteSpace(deliveryPath))
				return tariffs;

			await SetParcelProperties(parcel, ct);

			if (!await _browser.Select("#calc_calculate_btn", ct))
				throw new InvalidOperationException("Can't find calculate button");
			_browser.Click();

			if (!await _browser.WaitForAjax(5000, ct))
				throw new TimeoutException("Failed to wait for cost calculation");

			await _browser.ExecuteJs(JsCode, ct);
			var itariffs = (await _browser.ExecuteJs("return fragma.modules.dpdTariffs.getTariffs()", ct) as IList);
			foreach (dynamic itariff in itariffs)
			{
				var dict = itariff as Dictionary<string, object>;
				var serviceName = dict["serviceName"].ToString();
				var cost = dict["cost"].ToString();
				var tariff = new Tariff
				{
					ProviderType = TariffProviderType.DPD,
					SubProviderName = serviceName,
					DeliveryMethod = DeliveryMethod.ToDoor,
					DeliveryPath = deliveryPath,
					Price = decimal.Parse(cost, CultureInfo.InvariantCulture)
				};
				var days = dict["days"].ToString();
				var times = days.Split('-');
				var min = TimeSpan.Zero;
				min = new TimeSpan(int.Parse(times[0].Trim()), 0, 0, 0);
				var max = min;
				if (times.Count() > 1)
					max = new TimeSpan(int.Parse(times[1].Trim()), 0, 0, 0);
				tariff.MinDeliveryTime = min;
				tariff.MaxDeliveryTime = max;
				tariff.DeliveryTime = max;
				tariffs.Add(tariff);
			}
			return tariffs;
		}

		private async Task<List<Tariff>> Estimate(string icn, Parcel parcel, DeliveryOptions deliveryOptionsoptions, CancellationToken ct)
		{
			var browser = _browsers[icn];
			var deliveryPath = await FillInCities(browser, parcel, ct);

			await FillInParcelProperties(browser, parcel, ct);

			await FillInExtraProperties(browser, parcel, deliveryOptionsoptions, ct);

			var tariffs = await GetTariffs(browser, ct);
			tariffs.ForEach(t =>
			{
				t.DeliveryPath = deliveryPath;
				t.Icn = icn;
			});
			return tariffs;
		}

		public override void WriteToParcel(Parcel output, ParcelableWriteFlags flags)
		{
			base.WriteToParcel(output, flags);
			output.WriteInt(PrevFirstVisiblePosition);
			output.WriteInt(PrevFirstVisibleChildHeight);
			output.WriteInt(PrevScrolledChildrenHeight);
			output.WriteInt(PrevScrollY);
			output.WriteInt(ScrollY);
			int numOfChildren = ChildrenHeights == null ? 0 : ChildrenHeights.Size();
			output.WriteInt(numOfChildren);

			Debug.Assert(ChildrenHeights != null, "childrenHeights != null");
			for (int i = 0; i < numOfChildren; i++)
			{
				output.WriteInt(ChildrenHeights.KeyAt(i));
				output.WriteInt(ChildrenHeights.ValueAt(i));
			}
		}

 public HomeModule()
 {
   Get["/form"] = _ => {
     return View["form.html"];
   };
   Get["/shipping"] = _ => {
     Parcel myParcel = new Parcel(Request.Query["Width"],Request.Query["Height"],Request.Query["Length"],Request.Query["Weight"]);
     ParcelVariables parcelVariables = new ParcelVariables
     {
       Width = myParcel.GetWidth(),
       Height = myParcel.GetHeight(),
       Length = myParcel.GetLength(),
       Weight = myParcel.GetWeight(),
       Volume = myParcel.Volume(),
       CostToShip = myParcel.CostToShip()
     };
     return View["shipping.html", parcelVariables];
   };
 }