Exemplo n.º 1
0
 /// <summary>
 /// Adds an item into the bundle.
 /// </summary>
 /// <param name="key">The key to identify the item with. If an item with the key already exists in the bundle, this method will not succeed.</param>
 /// <param name="value">The value of the item.</param>
 /// <param name="offset">The zero-based byte offset in value from which to add to the bundle.</param>
 /// <param name="count">The maximum number of bytes to add to the bundle starting with offset.</param>
 /// <exception cref="System.ArgumentOutOfRangeException">Thrown when the offset or count is out of range.</exception>
 /// <exception cref="System.ArgumentException">Thrown when the key already exists or when there is an invalid parameter.</exception>
 /// <exception cref="System.ArgumentNullException">Thrown when a value is null.</exception>
 /// <exception cref="System.InvalidOperationException">Thrown when out of memory or when the bundle instance has been disposed.</exception>
 /// <example>
 /// <code>
 /// Tizen.Applications.Bundle bundle = new Tizen.Applications.Bundle();
 /// byte[] byteArray = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 /// bundle.AddItem("byte_array", byteArray, 2, 3);
 /// </code>
 /// </example>
 /// <since_tizen> 3 </since_tizen>
 public void AddItem(string key, byte[] value, int offset, int count)
 {
     if (!_keys.Contains(key))
     {
         if (value == null)
         {
             throw new ArgumentNullException("value");
         }
         if (offset < 0)
         {
             throw new ArgumentOutOfRangeException("offset", offset, "Cannot be less than 0");
         }
         if (offset > value.Length - 1)
         {
             throw new ArgumentOutOfRangeException("offset", offset, "Greater than last index of array");
         }
         if (count < 1)
         {
             throw new ArgumentOutOfRangeException("count", count, "Must be at least 1");
         }
         if (offset + count > value.Length)
         {
             throw new ArgumentException("The count is too large for the specified offset");
         }
         // Code is in Interop file because it is unsafe
         int ret = Interop.Bundle.UnsafeCode.AddItem(_handle, key, value, offset, count);
         BundleErrorFactory.CheckAndThrowException(ret, _handle);
         _keys.Add(key);
     }
     else
     {
         throw new ArgumentException("Key already exists", "key");
     }
 }
Exemplo n.º 2
0
 /// <summary>
 /// Adds an item into the bundle.
 /// </summary>
 /// <param name="key">The key to identify the item with. If an item with the key already exists in the bundle, this method will not succeed.</param>
 /// <param name="value">The value of the item.</param>
 /// <exception cref="System.ArgumentException">Thrown when the key already exists or when there is an invalid parameter.</exception>
 /// <exception cref="System.InvalidOperationException">Thrown when out of memory or when the bundle instance has been disposed.</exception>
 /// <example>
 /// <code>
 /// Tizen.Applications.Bundle bundle = new Tizen.Applications.Bundle();
 /// bundle.AddItem("string", "a_string");
 /// </code>
 /// </example>
 /// <since_tizen> 3 </since_tizen>
 public void AddItem(string key, string value)
 {
     if (!_keys.Contains(key))
     {
         int ret = Interop.Bundle.AddString(_handle, key, value);
         BundleErrorFactory.CheckAndThrowException(ret, _handle);
         _keys.Add(key);
     }
     else
     {
         throw new ArgumentException("Key already exists", "key");
     }
 }
Exemplo n.º 3
0
 /// <summary>
 /// Adds an item into the bundle.
 /// </summary>
 /// <param name="key">The key to identify the item with. If an item with the key already exists in the bundle, this method will not succeed.</param>
 /// <param name="value">The value of the item.</param>
 /// <exception cref="System.ArgumentException">Thrown when the key already exists or when there is an invalid parameter.</exception>
 /// <exception cref="System.InvalidOperationException">Thrown when out of memory or when the bundle instance has been disposed.</exception>
 /// <example>
 /// <code>
 /// Tizen.Applications.Bundle bundle = new Tizen.Applications.Bundle();
 /// string[] stringArray = { "a", "b", "c" };
 /// bundle.AddItem("string_array", stringArray);
 /// </code>
 /// </example>
 /// <since_tizen> 3 </since_tizen>
 public void AddItem(string key, IEnumerable <string> value)
 {
     if (!_keys.Contains(key))
     {
         string[] valueArray = value.Select(v => v == null ? string.Empty : v).ToArray();
         int      ret        = Interop.Bundle.AddStringArray(_handle, key, valueArray, valueArray.Count());
         BundleErrorFactory.CheckAndThrowException(ret, _handle);
         _keys.Add(key);
     }
     else
     {
         throw new ArgumentException("Key already exists", "key");
     }
 }
Exemplo n.º 4
0
        /// <summary>
        /// Gets the value of a bundle item with a specified key.
        /// </summary>
        /// <param name="key">The key of the bundle item whose value is desired.</param>
        /// <returns>The value of the bundle item.</returns>
        /// <exception cref="System.ArgumentException">Thrown when the key does not exist or when there is an invalid parameter.</exception>
        /// <exception cref="System.InvalidOperationException">Thrown when the bundle instance has been disposed.</exception>
        /// <example>
        /// <code>
        /// Tizen.Applications.Bundle bundle = new Tizen.Applications.Bundle();
        /// bundle.AddItem("string", "a_string");
        /// if (bundle.Contains("string"))
        /// {
        ///     object aValue = bundle.GetItem("string");
        ///     if (bundle.Is&lt;string&gt;("string");)
        ///     {
        ///         string aString = (string)aValue;
        ///         Console.WriteLine(aString);
        ///     }
        /// }
        /// </code>
        /// </example>
        /// <since_tizen> 3 </since_tizen>
        public object GetItem(string key)
        {
            if (_keys.Contains(key))
            {
                int type = Interop.Bundle.GetType(_handle, key);
                BundleErrorFactory.CheckAndThrowException(ErrorFacts.GetLastResult(), _handle);
                switch (type)
                {
                case (int)BundleType.String:
                    // get string
                    IntPtr stringPtr;
                    int    retString = Interop.Bundle.GetString(_handle, key, out stringPtr);
                    BundleErrorFactory.CheckAndThrowException(retString, _handle);
                    string stringValue = Marshal.PtrToStringAnsi(stringPtr);
                    if (stringValue == null)
                    {
                        return(string.Empty);
                    }
                    return(stringValue);

                case (int)BundleType.StringArray:
                    // get string array
                    int    stringArraySize;
                    IntPtr stringArrayPtr = Interop.Bundle.GetStringArray(_handle, key, out stringArraySize);
                    BundleErrorFactory.CheckAndThrowException(ErrorFacts.GetLastResult(), _handle);
                    string[] stringArray;
                    IntPtrToStringArray(stringArrayPtr, stringArraySize, out stringArray);
                    return(stringArray);

                case (int)BundleType.Byte:
                    // get byte array
                    IntPtr byteArrayPtr;
                    int    byteArraySize;
                    int    retByte = Interop.Bundle.GetByte(_handle, key, out byteArrayPtr, out byteArraySize);
                    BundleErrorFactory.CheckAndThrowException(retByte, _handle);
                    byte[] byteArray = new byte[byteArraySize];
                    Marshal.Copy(byteArrayPtr, byteArray, 0, byteArraySize);
                    return(byteArray);

                default:
                    throw new ArgumentException("Key does not exist in the bundle", "key");
                }
            }
            else
            {
                throw new ArgumentException("Key does not exist in the bundle (may be null or empty string)", "key");
            }
        }
Exemplo n.º 5
0
 /// <summary>
 /// Removes a bundle item with a specific key from a Bundle.
 /// </summary>
 /// <param name="key">The key of the item to delete.</param>
 /// <returns>true if the item is successfully found and removed, false otherwise (even if the item is not found).</returns>
 /// <exception cref="System.ArgumentException">Thrown when there is an invalid parameter.</exception>
 /// <exception cref="System.InvalidOperationException">Thrown when the bundle instance has been disposed.</exception>
 /// <example>
 /// <code>
 /// Tizen.Applications.Bundle bundle = new Tizen.Applications.Bundle();
 /// bundle.AddItem("string", "a_string");
 /// if (bundle.Contains("string"))
 /// {
 ///     if (bundle.RemoveItem("string"))
 ///     {
 ///         Console.WriteLine("Removed");
 ///     }
 /// }
 /// </code>
 /// </example>
 /// <since_tizen> 3 </since_tizen>
 public bool RemoveItem(string key)
 {
     if (_keys.Contains(key))
     {
         int ret = Interop.Bundle.RemoveItem(_handle, key);
         if (ret == (int)BundleErrorFactory.BundleError.KeyNotAvailable)
         {
             return(false);
         }
         BundleErrorFactory.CheckAndThrowException(ret, _handle);
         _keys.Remove(key);
         return(true);
     }
     else
     {
         return(false);
     }
 }
Exemplo n.º 6
0
 /// <summary>
 /// The bundle constructor.
 /// </summary>
 /// <exception cref="System.InvalidOperationException">Thrown when out of memory.</exception>
 /// <example>
 /// <code>
 /// Tizen.Applications.Bundle bundle = new Tizen.Applications.Bundle();
 /// </code>
 /// </example>
 /// <since_tizen> 3 </since_tizen>
 public Bundle()
 {
     _handle = Interop.Bundle.Create();
     BundleErrorFactory.CheckAndThrowException(ErrorFacts.GetLastResult(), _handle);
     _keys = new HashSet <string>();
 }