/// <summary> /// Sends the select request to the provider application. /// </summary> /// <remarks>The OnSelectResult will recieve the result of this API.</remarks> /// <param name="columnList">Select the target column list.</param> /// <param name="where">The Where statement for the select query.</param> /// <param name="order">The Order statement for the select query.</param> /// <param name="pageNumber">Select the target page number.</param> /// <param name="countPerPage">Select the row count per page.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parmaeter.</exception> /// <exception cref="UnauthorizedAccessException">Thrown in case if a permission is denied..</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege> /// <since_tizen> 3 </since_tizen> public void Select(string[] columnList, string where, string order, int pageNumber = 1, int countPerPage = 20) { int reqId, i; ResultType ret; if (columnList == null || columnList.Length == 0) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "column_list"); } for (i = 0; i < columnList.Length; i++) { if (string.IsNullOrEmpty(columnList[i])) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "column_list index " + i.ToString()); } } _lock.WaitOne(); ret = Interop.DataControl.Select(_handle, columnList, columnList.Length, where, order, pageNumber, countPerPage, out reqId); _lock.ReleaseMutex(); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false, "Select"); } Log.Info(LogTag, "select end. " + reqId.ToString()); CallbackManager.RegisterReqId(reqId, this); }
/// <summary> /// Initializes the Consumer class with the providerId and the ataId. /// </summary> /// <param name="providerId">The DataControl Provider ID.</param> /// <param name="dataId">The DataControl Data ID.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parmaeter.</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <since_tizen> 3 </since_tizen> public Consumer(string providerId, string dataId) { ResultType ret; if (string.IsNullOrEmpty(providerId)) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "providerId"); } if (string.IsNullOrEmpty(dataId)) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "dataId"); } ret = Interop.DataControl.DataControlCreate(out _handle); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false, "Creating data control handle is failed"); } Interop.DataControl.DataControlSetProviderId(_handle, providerId); Interop.DataControl.DataControlSetDataId(_handle, dataId); _lock.WaitOne(); CallbackManager.RegisterCallback(_handle, providerId); _lock.ReleaseMutex(); _dataID = dataId; _providerID = providerId; }
internal BulkData(Interop.DataControl.SafeBulkDataHandle handle) { ResultType ret; int count, i; ret = Interop.DataControl.BulkCreate(out _handle); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, true, "BulkCreate"); } ret = Interop.DataControl.BulkGetCount(handle, out count); for (i = 0; i < count; i++) { IntPtr bundleHandle; Bundle bundle; ret = Interop.DataControl.BulkGetData(handle, i, out bundleHandle); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, true, "BulkGetData"); } bundle = new Bundle(new SafeBundleHandle(bundleHandle, false)); ret = Interop.DataControl.BulkAdd(_handle, bundle.SafeBundleHandle); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, true, "BulkAdd"); } } }
/// <summary> /// Sends the update request to the provider application. /// </summary> /// <remarks>The OnUpdateResult will recieve result of this API.</remarks> /// <param name="updateData">The update data.</param> /// <param name="where">The Where statement for the query.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parmaeter.</exception> /// <exception cref="UnauthorizedAccessException">Thrown in case if a permission is denied.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown when the message has exceeded the maximum limit (1MB).</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege> /// <since_tizen> 3 </since_tizen> public void Update(Bundle updateData, string where) { int reqId; ResultType ret; if (updateData == null || updateData.SafeBundleHandle.IsInvalid) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "insertData"); } if (string.IsNullOrEmpty(where)) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "where"); } _lock.WaitOne(); ret = Interop.DataControl.Update(_handle, updateData.SafeBundleHandle, where, out reqId); _lock.ReleaseMutex(); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false, "Update"); } CallbackManager.RegisterReqId(reqId, this); }
/// <summary> /// Initializes the SelectResult class with the cursor and the result. /// </summary> /// <param name="cursor">The cursor with the selected data.</param> /// <param name="result">The select request result.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public SelectResult(ICursor cursor, bool result) { int i; if (result == true && cursor == null) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "cursor"); } if (result == true && (cursor is MatrixCursor) == false) { if (cursor.GetColumnCount() <= 0) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "column count"); } for (i = 0; i < cursor.GetColumnCount(); i++) { if (string.IsNullOrEmpty(cursor.GetColumnName(i))) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "column name index " + i.ToString()); } if (cursor.GetColumnType(i) < ColumnType.ColumnTypeInt || cursor.GetColumnType(i) > ColumnType.ColumnTypeBlob) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "column type index" + i.ToString()); } } } ResultCursor = cursor; Result = result; }
/// <summary> /// Returns the column name at the given zero-based column index. /// </summary> /// <param name="index">The target column index.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public string GetColumnName(int index) { if (index < 0 || index >= _columnTypes.Length) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false); } return(_columnNames[index]); }
/// <summary> /// Initializes the Provider class with the dataID. /// </summary> /// <param name="dataID">The DataControl Data ID.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public Provider(string dataID) { if (string.IsNullOrEmpty(dataID)) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "dataID"); } DataID = dataID; }
/// <summary> /// Initializes the BulkData class. /// </summary> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <since_tizen> 3 </since_tizen> public BulkData() { ResultType ret; ret = Interop.DataControl.BulkCreate(out _handle); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, true, "BulkCreate"); } }
/// <summary> /// Initializes the MapGetResult class with the data and the result. /// </summary> /// <param name="valueLIst">The MapGet request result data.</param> /// <param name="result">The MapGet request result.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public MapGetResult(string[] valueLIst, bool result) { if (result == true && valueLIst == null) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "valueLIst"); } ValueList = valueLIst; Result = result; }
/// <summary> /// Initializes the InsertResult class with the bulkResultData and the result. /// </summary> /// <param name="bulkResultData">The bulk insert request result data.</param> /// <param name="result">The bulk insert request result.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public BulkInsertResult(BulkResultData bulkResultData, bool result) { if (result == true && (bulkResultData == null || bulkResultData.SafeBulkDataHandle.IsInvalid)) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "bulkResultData"); } BulkResultData = bulkResultData; Result = result; }
/// <summary> /// Returns the value of the requested column as a BLOB. /// </summary> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public byte[] GetBlobValue(int index) { byte[] byte_array; if (index < 0 || index >= _columnTypes.Length) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false); } byte_array = GetValue(index); return(byte_array); }
/// <summary> /// Gets the current result data count. /// </summary> /// <since_tizen> 3 </since_tizen> public int GetCount() { int count; ResultType ret; ret = Interop.DataControl.BulkResultGetCount(_handle, out count); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, true, "BulkResultGetCount"); } return(count); }
private byte[] GetValue(int index) { byte[] int_tmp = new byte[sizeof(int)]; byte[] ret_array; ColumnType type; int size, read_len; MoveToColumn(index); read_len = _fs.Read(int_tmp, 0, int_tmp.Length); if (read_len != int_tmp.Length) { ErrorFactory.ThrowException(ResultType.IoError, true, "Column Type " + index.ToString()); } type = (ColumnType)BitConverter.ToInt32(int_tmp, 0); if (type != _columnTypes[index]) { if ((int)type == ColumnTypeNull && (_columnTypes[index] == ColumnType.ColumnTypeBlob || _columnTypes[index] == ColumnType.ColumnTypeString)) { return(null); /* null type */ } ErrorFactory.ThrowException(ResultType.IoError, true, "Type mismatch " + index.ToString()); } read_len = _fs.Read(int_tmp, 0, int_tmp.Length); if (read_len != int_tmp.Length) { ErrorFactory.ThrowException(ResultType.IoError, true, "Column size " + index.ToString()); } size = BitConverter.ToInt32(int_tmp, 0); if (size < 0) { ErrorFactory.ThrowException(ResultType.IoError, true, "Invalid data size " + index.ToString()); } ret_array = new byte[size]; read_len = _fs.Read(ret_array, 0, ret_array.Length); if (read_len != ret_array.Length) { ErrorFactory.ThrowException(ResultType.IoError, true, "Column value size " + index.ToString()); return(null); } return(ret_array); }
/// <summary> /// Sends the delete request to the provider application. /// </summary> /// <remarks>The OnDeleteResult will recieve the result of this API</remarks> /// <param name="where">The Where statement for the delete query.</param> /// <exception cref="UnauthorizedAccessException">Thrown in case if a permission is denied.</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege> /// <since_tizen> 3 </since_tizen> public void Delete(string where) { int reqId; ResultType ret; _lock.WaitOne(); ret = Interop.DataControl.Delete(_handle, where, out reqId); _lock.ReleaseMutex(); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false, "Delete"); } CallbackManager.RegisterReqId(reqId, this); }
/// <summary> /// Adds the bulk data. /// </summary> /// <param name="data">Bulk data</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public void Add(Bundle data) { ResultType ret; if (data == null || data.SafeBundleHandle.IsInvalid) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "data"); } ret = Interop.DataControl.BulkAdd(_handle, data.SafeBundleHandle); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, true, "BulkAdd"); } }
/// <summary> /// Sends a data change notification to consumer applications which have successfully added a data change listen. /// </summary> /// <param name="type">The changed data type.</param> /// <param name="changedData">Customized information about the changed data.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <exception cref="UnauthorizedAccessException">Thrown in case a permission is denied.</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <since_tizen> 3 </since_tizen> public void SendDataChange(ChangeType type, Bundle changedData) { ResultType ret; if (changedData == null || changedData.SafeBundleHandle.IsInvalid) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "changedData"); } ret = Interop.DataControl.SendDataChange(this.DataID, type, changedData.SafeBundleHandle); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false); } }
/// <summary> /// Returns the result at the given zero-based data index. /// </summary> /// <param name="index">The target result index.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public int GetResult(int index) { IntPtr bundlePtr; ResultType ret; int result; if (index < 0) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "index"); } ret = Interop.DataControl.BulkResultGetData(_handle, index, out bundlePtr, out result); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, true, "BulkResultGetData"); } return(result); }
/// <summary> /// Sends the map set request to the provider application. /// </summary> /// <remarks>The OnMapSetResult will recieve the result of this API.</remarks> /// <param name="key">The key of the value to replace.</param> /// <param name="oldValue">The value to be replaced.</param> /// <param name="newValue"> The new value that replaces the existing value.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parmaeter.</exception> /// <exception cref="UnauthorizedAccessException">Thrown in case if a permission is denied.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown when message has exceeded the maximum limit (1MB).</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege> /// <since_tizen> 3 </since_tizen> public void MapSet(string key, string oldValue, string newValue) { int reqId; ResultType ret; if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(oldValue) || string.IsNullOrEmpty(newValue)) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false); } _lock.WaitOne(); ret = Interop.DataControl.MapSet(_handle, key, oldValue, newValue, out reqId); _lock.ReleaseMutex(); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false, "MapSet"); } CallbackManager.RegisterReqId(reqId, this); }
/// <summary> /// Sends the map get request to the provider application. /// </summary> /// <remarks>The OnMapGetResult will recieve the result of this API.</remarks> /// <param name="key">The key of the value list to obtain.</param> /// <param name="pageNumber">The page number of the value set.</param> /// <param name="countPerPage">The desired maximum count of the data items per page.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parmaeter.</exception> /// <exception cref="UnauthorizedAccessException">Thrown in case if a permission is denied.</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege> /// <since_tizen> 3 </since_tizen> public void MapGet(string key, int pageNumber = 1, int countPerPage = 20) { int reqId; ResultType ret; if (string.IsNullOrEmpty(key) || pageNumber <= 0 || countPerPage <= 0) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false); } _lock.WaitOne(); ret = Interop.DataControl.MapGet(_handle, key, out reqId, pageNumber, countPerPage); _lock.ReleaseMutex(); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false, "MapGet"); } CallbackManager.RegisterReqId(reqId, this); }
/// <summary> /// Sends the insert request to the provider application. /// </summary> /// <remarks>The OnInsertResult will recieve the result of this API.</remarks> /// <param name="insertData">The insert data.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parmaeter.</exception> /// <exception cref="UnauthorizedAccessException">Thrown in case if a permission is denied.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown when the message has exceeded the maximum limit (1MB).</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege> /// <since_tizen> 3 </since_tizen> public void Insert(Bundle insertData) { int reqId; ResultType ret; if (insertData == null || insertData.SafeBundleHandle.IsInvalid) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "insertData"); } _lock.WaitOne(); ret = Interop.DataControl.Insert(_handle, insertData.SafeBundleHandle, out reqId); _lock.ReleaseMutex(); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false, "Insert"); } CallbackManager.RegisterReqId(reqId, this); }
/// <summary> /// Returns the value of the requested column as a double. /// </summary> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public double GetDoubleValue(int index) { double ret; byte[] byte_array; if (index < 0 || index >= _columnTypes.Length) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false); } byte_array = GetValue(index); if (byte_array == null) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false); } ret = BitConverter.ToDouble(byte_array, 0); return(ret); }
/// <summary> /// Sends the map bulk add request to the provider application. /// </summary> /// <remarks>The OnMapBulkAddResult will recieve the result of this API.</remarks> /// <param name="addData">The map bulk add data.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parmaeter.</exception> /// <exception cref="UnauthorizedAccessException">Thrown in case if a permission is denied.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown when the message has exceeded the maximum limit (1MB).</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege> /// <since_tizen> 3 </since_tizen> public void MapBulkAdd(BulkData addData) { int reqId; ResultType ret; if (addData == null || addData.SafeBulkDataHandle.IsInvalid) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "addData"); } _lock.WaitOne(); ret = Interop.DataControl.BulkAdd(_handle, addData.SafeBulkDataHandle, out reqId); _lock.ReleaseMutex(); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false, "BulkAdd"); } CallbackManager.RegisterReqId(reqId, this); }
/// <summary> /// Returns the data at the given zero-based data index. /// </summary> /// <param name="index">The target data index.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public Bundle GetData(int index) { IntPtr bundlePtr; Bundle bundle; ResultType ret; if (index < 0) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "index"); } ret = Interop.DataControl.BulkGetData(_handle, index, out bundlePtr); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, true, "BulkGetData"); } bundle = new Bundle(new SafeBundleHandle(bundlePtr, false)); return(bundle); }
/// <summary> /// Returns the value of the requested column as a string. /// </summary> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public string GetStringValue(int index) { string ret; byte[] byte_array; if (index < 0 || index >= _columnTypes.Length) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false); } byte_array = GetValue(index); if (byte_array == null) { return(null); } ret = Encoding.UTF8.GetString(byte_array).TrimEnd('\0'); return(ret); }
/// <summary> /// Listens the DataChange event. /// </summary> /// <remarks>The OnDataChangeListenResult will recieve the result of this API.</remarks> /// <remarks>If success, the OnDataChange will recieve the DataChange event.</remarks> /// <exception cref="UnauthorizedAccessException">Thrown in case if a permission is denied.</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege> /// <since_tizen> 3 </since_tizen> public void DataChangeListen() { ResultType ret; _lock.WaitOne(); /* Only one callback is allowed for every obejct */ if (_changeCallbackID > 0) { _lock.ReleaseMutex(); return; } _dataChangeCallback = new Interop.DataControl.DataChangeCallback(DataChange); _addCallbackResultCallback = new Interop.DataControl.AddCallbackResultCallback(DataChangeListenResult); ret = Interop.DataControl.AddDataChangeCallback(_handle, _dataChangeCallback, IntPtr.Zero, _addCallbackResultCallback, IntPtr.Zero, out _changeCallbackID); _lock.ReleaseMutex(); if (ret != ResultType.Success) { ErrorFactory.ThrowException(ret, false, "DataChangeListen"); } }
private void MoveToColumn(int ColumnIndex) { int i, tmp_position; byte[] int_tmp = new byte[sizeof(int)]; int read_len; long seek_len; seek_len = _fs.Seek(_rowFieldOffset[_currentRowIndex], SeekOrigin.Begin); if (seek_len != _rowFieldOffset[_currentRowIndex]) { ErrorFactory.ThrowException(ResultType.IoError, true, "Row index " + _currentRowIndex.ToString()); } for (i = 0; i < ColumnIndex; i++) { /* type(int) size(int) value */ switch (_columnTypes[i]) { case ColumnType.ColumnTypeInt: tmp_position = sizeof(int) * 2 + sizeof(Int64); _fs.Seek(tmp_position, SeekOrigin.Current); break; case ColumnType.ColumnTypeDouble: tmp_position = sizeof(int) * 2 + sizeof(double); _fs.Seek(tmp_position, SeekOrigin.Current); break; case ColumnType.ColumnTypeString: tmp_position = sizeof(int); _fs.Seek(tmp_position, SeekOrigin.Current); read_len = _fs.Read(int_tmp, 0, int_tmp.Length); if (read_len != int_tmp.Length) { ErrorFactory.ThrowException(ResultType.IoError, true, "Column Index " + ColumnIndex.ToString()); } tmp_position = BitConverter.ToInt32(int_tmp, 0); if (tmp_position > 0) { _fs.Seek(tmp_position, SeekOrigin.Current); } break; case ColumnType.ColumnTypeBlob: tmp_position = sizeof(int); _fs.Seek(tmp_position, SeekOrigin.Current); read_len = _fs.Read(int_tmp, 0, int_tmp.Length); if (read_len != int_tmp.Length) { ErrorFactory.ThrowException(ResultType.IoError, true, "Column Index " + ColumnIndex.ToString()); } tmp_position = BitConverter.ToInt32(int_tmp, 0); if (tmp_position > 0) { _fs.Seek(tmp_position, SeekOrigin.Current); } break; } } }
/// <summary> /// Initializes the MatrixCursor class with columnNames and columnTypes. /// </summary> /// <param name="columnNames">The MatrixCursor's column name list.</param> /// <param name="columnTypes">The MatrixCursor's column type list.</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <since_tizen> 3 </since_tizen> public MatrixCursor(string[] columnNames, ColumnType[] columnTypes) { byte[] byte_tmp, length_tmp, string_tmp; int i, total_len_of_column_names = 0; if (columnNames == null || columnTypes == null || (columnNames.Length != columnTypes.Length) || columnNames.Length < 1) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false); } for (i = 0; i < columnNames.Length; i++) { if (string.IsNullOrEmpty(columnNames[i])) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "columnNames index " + i.ToString()); } } for (i = 0; i < columnTypes.Length; i++) { if (columnTypes[i] < ColumnType.ColumnTypeInt || columnTypes[i] > ColumnType.ColumnTypeBlob) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "columnTypes index" + i.ToString()); } } _columnNames = columnNames; _columnTypes = columnTypes; _cursorPath = FileManager.OpenFileStream(Thread.CurrentThread.ManagedThreadId); if (_cursorPath == null) { Log.Error(LogTag, "Unable to create a cursor file : " + _cursorPath); ErrorFactory.ThrowException(ResultType.IoError, true); } _fs = new FileStream(_cursorPath, FileMode.Create); /* column count */ byte_tmp = BitConverter.GetBytes(columnNames.Length); _fs.Write(byte_tmp, 0, byte_tmp.Length); /* column type */ for (i = 0; i < columnTypes.Length; i++) { byte_tmp = BitConverter.GetBytes((int)_columnTypes[i]); _fs.Write(byte_tmp, 0, byte_tmp.Length); } /* column name */ for (i = 0; i < columnTypes.Length; i++) { string_tmp = Encoding.UTF8.GetBytes(columnNames[i]); byte_tmp = new byte[string_tmp.Length + 1];/*insert null */ string_tmp.CopyTo(byte_tmp, 0); length_tmp = BitConverter.GetBytes(byte_tmp.Length); total_len_of_column_names += length_tmp.Length; _fs.Write(length_tmp, 0, length_tmp.Length); _fs.Write(byte_tmp, 0, byte_tmp.Length); } /* total length of column names */ byte_tmp = BitConverter.GetBytes(total_len_of_column_names); _fs.Write(byte_tmp, 0, byte_tmp.Length); _rowCountPosition = _fs.Position; /* row count */ byte_tmp = BitConverter.GetBytes(_rowCount); _fs.Write(byte_tmp, 0, byte_tmp.Length); _fs.Flush(); }
/// <summary> /// Adds a new row to the end with the given column values. /// </summary> /// <param name="columnValues">New column values</param> /// <exception cref="ArgumentException">Thrown in case of an invalid parameter.</exception> /// <since_tizen> 3 </since_tizen> public void AddRow(object[] columnValues) { int i, size = 0; byte[] type_array, length_array, value_array = null, string_array, byte_tmp; if (columnValues == null || columnValues.Length <= 0 || columnValues.Length != _columnTypes.Length) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false); } using (MemoryStream ms = new MemoryStream()) { for (i = 0; i < _columnTypes.Length; i++) { type_array = BitConverter.GetBytes((int)_columnTypes[i]); switch (_columnTypes[i]) { case ColumnType.ColumnTypeInt: if (!(columnValues[i] is Int64) && !(columnValues[i] is Int32)) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "Type mismatch :Index " + i.ToString()); } value_array = BitConverter.GetBytes(Convert.ToUInt64(columnValues[i])); size = value_array.Length; break; case ColumnType.ColumnTypeDouble: if (!(columnValues[i] is Double)) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "Type mismatch :Index " + i.ToString()); } value_array = BitConverter.GetBytes(Convert.ToDouble(columnValues[i])); size = value_array.Length; break; case ColumnType.ColumnTypeString: if (columnValues[i] == null) { type_array = BitConverter.GetBytes(ColumnTypeNull); size = 0; break; } if (!(columnValues[i] is string)) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "Type mismatch :Index " + i.ToString()); } string_array = Encoding.UTF8.GetBytes(Convert.ToString(columnValues[i])); value_array = new byte[string_array.Length + 1]; /*insert null */ string_array.CopyTo(value_array, 0); size = value_array.Length; break; case ColumnType.ColumnTypeBlob: if (columnValues[i] == null) { type_array = BitConverter.GetBytes(ColumnTypeNull); size = 0; break; } if (!(columnValues[i] is byte[])) { ErrorFactory.ThrowException(ResultType.InvalidParameter, false, "Type mismatch :Index " + i.ToString()); } value_array = (byte[])columnValues[i]; size = value_array.Length; break; } ms.Write(type_array, 0, type_array.Length); length_array = BitConverter.GetBytes(size); ms.Write(length_array, 0, length_array.Length); if (size > 0) { ms.Write(value_array, 0, value_array.Length); } } /* update row count */ _rowCount++; byte_tmp = BitConverter.GetBytes(_rowCount); _fs.Seek(_rowCountPosition, SeekOrigin.Begin); _fs.Write(byte_tmp, 0, byte_tmp.Length); _fs.Seek(0, SeekOrigin.End); _rowFieldOffset.Add(_fs.Position); ms.WriteTo(_fs);/* row data */ _fs.Flush(); Log.Debug(LogTag, "_fs pos = " + _fs.Position.ToString()); Log.Debug(LogTag, "_fs len = " + _fs.Length.ToString()); } }
/// <summary> /// Starts the Provider service. /// </summary> /// <remarks>Only one Provider service can be run for each process.</remarks> /// <exception cref="UnauthorizedAccessException">Thrown in case a permission is denied.</exception> /// <exception cref="InvalidOperationException">Thrown in case of any internal error.</exception> /// <privilege>http://tizen.org/privilege/datasharing</privilege> /// <since_tizen> 3 </since_tizen> public void Run() { ResultType ret; _lock.WaitOne(); if (_providerDict.ContainsKey(DataID)) { _lock.ReleaseMutex(); ErrorFactory.ThrowException((ResultType)1, true, "The provider is already running"); return; } if (_providerDict.Count == 0) { Log.Debug(LogTag, "Provider create"); _sqlRequestCallbacks.Insert = new Interop.DataControl.SqlInsertRequestCallback(InsertRequest); _sqlRequestCallbacks.Select = new Interop.DataControl.SqlSelectRequestCallback(SelectRequest); _sqlRequestCallbacks.Update = new Interop.DataControl.SqlUpdateRequestCallback(UpdateRequest); _sqlRequestCallbacks.Delete = new Interop.DataControl.SqlDeleteRequestCallback(DeleteRequest); ret = Interop.DataControl.RegisterSqlRequest(ref _sqlRequestCallbacks, IntPtr.Zero); if (ret != ResultType.Success) { _lock.ReleaseMutex(); ErrorFactory.ThrowException(ret, false); } _sqlBulkCallback = new Interop.DataControl.SqlBulkInsertRequestCallback(BulkInsertRequest); ret = Interop.DataControl.RegisterSqlBulkRequest(_sqlBulkCallback, IntPtr.Zero); if (ret != ResultType.Success) { _lock.ReleaseMutex(); ErrorFactory.ThrowException(ret, false); } _mapRequestCallbacks.Add = new Interop.DataControl.MapAddRequestCallback(MapAddRequest); _mapRequestCallbacks.Remove = new Interop.DataControl.MapRemoveRequestCallback(MapRemoveRequest); _mapRequestCallbacks.Set = new Interop.DataControl.MapSetRequestCallback(MapSetRequest); _mapRequestCallbacks.Get = new Interop.DataControl.MapGetRequestCallback(MapGetRequest); ret = Interop.DataControl.RegisterMapRequest(ref _mapRequestCallbacks, IntPtr.Zero); if (ret != ResultType.Success) { _lock.ReleaseMutex(); ErrorFactory.ThrowException(ret, false); } _mapBulkCallback = new Interop.DataControl.MapBulkAddRequestCallback(MapBulkAddRequest); ret = Interop.DataControl.RegisterMapBulkRequest(_mapBulkCallback, IntPtr.Zero); if (ret != ResultType.Success) { _lock.ReleaseMutex(); ErrorFactory.ThrowException(ret, false); } if (_filterRegistered == false) { if (_filterCallback == null) { _filterCallback = new Interop.DataControl.DataChangeConsumerFilterCb(DataChangeListenFilter); } ret = Interop.DataControl.AddDataChangeConsumerFilterCallback( _filterCallback, IntPtr.Zero, out _filterCallbackID); if (ret != ResultType.Success) { _lock.ReleaseMutex(); ErrorFactory.ThrowException(ret, false); } } _filterRegistered = true; } _providerDict.Add(DataID, this); Log.Info(LogTag, "DataID :" + DataID + ", hash code : " + this.GetHashCode().ToString()); _isRunning = true; _lock.ReleaseMutex(); }
internal static void RegisterCallback(Interop.DataControl.SafeDataControlHandle handle, string providerId) { ResultType ret; Interop.DataControl.SqlResponseCallbacks sqlCallbacks; Interop.DataControl.SqlBulkInsertResponseCallback sqlBulkCallbacks; Interop.DataControl.MapResponseCallbacks mapCallbacks; Interop.DataControl.MapBulkAddResponseCallback mapBulkCallbacks; bool sqlRegistered = false; bool mapRegistered = false; if (_reqProviderList.ContainsKey(providerId)) { _reqProviderList[providerId]++; Log.Error(LogTag, "The data control is already set"); return; } sqlCallbacks.Insert = new Interop.DataControl.SqlInsertResponseCallback(InsertResponse); sqlCallbacks.Select = new Interop.DataControl.SqlSelectResponseCallback(SelectResponse); sqlCallbacks.Update = new Interop.DataControl.SqlUpdateResponseCallback(UpdateResponse); sqlCallbacks.Delete = new Interop.DataControl.SqlDeleteResponseCallback(DeleteResponse); ret = Interop.DataControl.RegisterSqlResponseCallback(handle, ref sqlCallbacks, IntPtr.Zero); if (ret != ResultType.Success) { Log.Error(LogTag, "Registering the sql callback function is failed : " + ret); } else { _sqlResponseCallbacks.Add(providerId, sqlCallbacks); sqlRegistered = true; } sqlBulkCallbacks = new Interop.DataControl.SqlBulkInsertResponseCallback(BulkInsertResponse); ret = Interop.DataControl.RegisterSqlBulkResponseCallback(handle, sqlBulkCallbacks, IntPtr.Zero); if (ret != ResultType.Success) { Log.Error(LogTag, "Registering the sql bulk callback function is failed : " + ret); } else { _sqlBulkResponseCallback.Add(providerId, sqlBulkCallbacks); } mapCallbacks.Add = new Interop.DataControl.MapAddResponseCallback(MapAddResponse); mapCallbacks.Set = new Interop.DataControl.MapSetResponseCallback(MapSetResponse); mapCallbacks.Get = new Interop.DataControl.MapGetResponseCallback(MapGetResponse); mapCallbacks.Remove = new Interop.DataControl.MapRemoveResponseCallback(MapRemoveResponse); ret = Interop.DataControl.RegisterMapResponse(handle, ref mapCallbacks, IntPtr.Zero); if (ret != ResultType.Success) { Log.Error(LogTag, "Registering the map callback function is failed : " + ret); } else { _mapResponseCallbacks.Add(providerId, mapCallbacks); mapRegistered = true; } mapBulkCallbacks = new Interop.DataControl.MapBulkAddResponseCallback(MapBulkAddResponse); ret = Interop.DataControl.RegisterMapBulkResponseCallback(handle, mapBulkCallbacks, IntPtr.Zero); if (ret != ResultType.Success) { Log.Error(LogTag, "Registering the map bulk callback function is failed : " + ret); } else { _mapBulkResponseCallback.Add(providerId, mapBulkCallbacks); } if (!mapRegistered && !sqlRegistered) { ErrorFactory.ThrowException(ret, true, "Registering the response callback function is failed"); } _reqProviderList.Add(providerId, 1); }