Add exception handling

Change-Id: I6f1b3bc1c1a56d7292c374852454b53abc3b3ed0

diff --git a/Tizen.Applications/Tizen.Applications.Managers/ApplicationManagerErrorFactory.cs b/Tizen.Applications/Tizen.Applications.Managers/ApplicationManagerErrorFactory.cs
new file mode 100755 (executable)
index 0000000..5aecc43
--- /dev/null
+++ b/Tizen.Applications/Tizen.Applications.Managers/ApplicationManagerErrorFactory.cs
@@ -0,0 +1,59 @@
+/// Copyright 2016 by Samsung Electronics, Inc.,
+///
+/// This software is the confidential and proprietary information
+/// of Samsung Electronics, Inc. ("Confidential Information"). You
+/// shall not disclose such Confidential Information and shall use
+/// it only in accordance with the terms of the license agreement
+/// you entered into with Samsung.
+using System;
+
+namespace Tizen.Applications.Managers
+{
+    internal enum ApplicationManagerError
+    {
+        None = Tizen.Internals.Errors.ErrorCode.None,
+        InvalidParameter = Tizen.Internals.Errors.ErrorCode.InvalidParameter,
+        OutOfMemory = Tizen.Internals.Errors.ErrorCode.OutOfMemory,
+        IoError = Tizen.Internals.Errors.ErrorCode.IoError,
+        NoSuchApp = -0x01110000 | 0x01,
+        DbFailed = -0x01110000 | 0x03,
+        InvalidPackage = -0x01110000 | 0x04,
+        AppNoRunning = -0x01110000 | 0x05,
+        RequestFailed = -0x01110000 | 0x06,
+        PermissionDenied = Tizen.Internals.Errors.ErrorCode.PermissionDenied
+    }
+
+    internal static class ApplicationManagerErrorFactory
+    {
+        private const string LogTag = "Tizen.Applications.Managers";
+
+        internal static void ExceptionChecker(int ret, IntPtr handle, string msg)
+        {
+            Log.Debug(LogTag, "ExceptionChecker");
+            ApplicationManagerError err = (ApplicationManagerError)ret;
+            switch(err)
+            {
+                case ApplicationManagerError.InvalidParameter:
+                    Log.Error(LogTag, msg);
+                    if (handle == IntPtr.Zero)
+                    {
+                        throw new InvalidOperationException("Invalid handle error occurred.");
+                    }
+                    throw new ArgumentException(err + " error occurred.");
+                case ApplicationManagerError.OutOfMemory:
+                case ApplicationManagerError.IoError:
+                case ApplicationManagerError.NoSuchApp:
+                case ApplicationManagerError.DbFailed:
+                case ApplicationManagerError.InvalidPackage:
+                case ApplicationManagerError.AppNoRunning:
+                case ApplicationManagerError.RequestFailed:
+                case ApplicationManagerError.PermissionDenied:
+                    Log.Error(LogTag, msg);
+                    throw new InvalidOperationException(err + " error occurred.");
+                default:
+                    break;
+            }
+        }
+
+    }
+}

diff --git a/Tizen.Applications/Tizen.Applications.Managers/ApplicationManagerImpl.cs b/Tizen.Applications/Tizen.Applications.Managers/ApplicationManagerImpl.cs
index 8157b800300f2b3a0777432f8112e7eec181e665..a91294168f2060937f851963f3a81e784019c0a1 100755 (executable)
--- a/Tizen.Applications/Tizen.Applications.Managers/ApplicationManagerImpl.cs
+++ b/Tizen.Applications/Tizen.Applications.Managers/ApplicationManagerImpl.cs
@@ -20,22 +20,25 @@ namespace Tizen.Applications.Managers
         private bool _disposed = false;
         private Interop.ApplicationManager.AppManagerAppContextEventCallback _applicationChangedEventCallback;
 
+        private const string LogTag = "Tizen.Applications.Managers";
+        private int ret = 0;
+
         private ApplicationManagerImpl()
         {
-            Console.WriteLine("ApplicationManagerImpl()");
+            Log.Debug(LogTag, "ApplicationManagerImpl()");
             RegisterApplicationChangedEvent();
         }
 
 
         ~ApplicationManagerImpl()
         {
-            Console.WriteLine("~ApplicationManagerImpl()");
+            Log.Debug(LogTag, "~ApplicationManagerImpl()");
             UnRegisterApplicationChangedEvent();
             Dispose(false);
         }
 
         internal event EventHandler<ApplicationChangedEventArgs> ApplicationLaunched;
-        internal event EventHandler<ApplicationChangedEventArgs> ApplicationTerminated;        
+        internal event EventHandler<ApplicationChangedEventArgs> ApplicationTerminated;
 
         internal static ApplicationManagerImpl Instance
         {
@@ -66,7 +69,7 @@ namespace Tizen.Applications.Managers
 
         internal async Task<IEnumerable<InstalledApplication>> GetInstalledAppsAsync()
         {
-            Console.WriteLine("GetInstalledAppsAsync()");
+            Log.Debug(LogTag, "GetInstalledAppsAsync()");
             return await Task.Run(() =>
             {
                 List<InstalledApplication> Result = new List<InstalledApplication>();
@@ -75,33 +78,45 @@ namespace Tizen.Applications.Managers
                 {
                     if (handle != IntPtr.Zero)
                     {
-                        IntPtr clonedHandle;
-                        Interop.ApplicationManager.AppInfoClone(out clonedHandle, handle);
+                        IntPtr clonedHandle = IntPtr.Zero;
+                        ret = Interop.ApplicationManager.AppInfoClone(out clonedHandle, handle);
+                        if (ret != 0)
+                        {
+                            ApplicationManagerErrorFactory.ExceptionChecker(ret, clonedHandle, "GetInstalledAppsAsync() failed.");
+                        }
                         InstalledApplication app = new InstalledApplication(clonedHandle);
                         Result.Add(app);
                         return true;
                     }
                     return false;
                 };
-                Interop.ApplicationManager.AppManagerForeachAppInfo(cb, IntPtr.Zero);
+                ret = Interop.ApplicationManager.AppManagerForeachAppInfo(cb, IntPtr.Zero);
+                if (ret != 0)
+                {
+                    ApplicationManagerErrorFactory.ExceptionChecker(ret, IntPtr.Zero, "GetInstalledAppsAsync() failed.");
+                }
                 return Result;
             });
         }
 
         internal async Task<IEnumerable<InstalledApplication>> GetInstalledAppsAsync(InstalledApplicationFilter filter)
         {
-            Console.WriteLine("GetInstalledAppsAsync(InstalledApplicationFilter filter)");
+            Log.Debug(LogTag, "GetInstalledAppsAsync(InstalledApplicationFilter filter)");
             return await Task.Run(() =>
             {
                 List<InstalledApplication> Result = new List<InstalledApplication>();
 
                 Interop.ApplicationManager.AppInfoFilterCallback cb = (IntPtr handle, IntPtr userData) =>
                 {
-                    Console.WriteLine("AppInfoFilterCallback");
+                    Log.Debug(LogTag, "AppInfoFilterCallback");
                     if (handle != IntPtr.Zero)
                     {
-                        IntPtr clonedHandle;
-                        Interop.ApplicationManager.AppInfoClone(out clonedHandle, handle);
+                        IntPtr clonedHandle = IntPtr.Zero;
+                        ret = Interop.ApplicationManager.AppInfoClone(out clonedHandle, handle);
+                        if (ret != 0)
+                        {
+                            ApplicationManagerErrorFactory.ExceptionChecker(ret, clonedHandle, "GetInstalledAppsAsync(InstalledApplicationFilter) failed.");
+                        }
                         InstalledApplication app = new InstalledApplication(clonedHandle);
                         Result.Add(app);
                         return true;
@@ -109,14 +124,18 @@ namespace Tizen.Applications.Managers
                     return false;
                 };
 
-                Interop.ApplicationManager.AppInfoFilterForeachAppinfo(filter.Handle, cb, IntPtr.Zero);
+                ret = Interop.ApplicationManager.AppInfoFilterForeachAppinfo(filter.Handle, cb, IntPtr.Zero);
+                if (ret != 0)
+                {
+                    ApplicationManagerErrorFactory.ExceptionChecker(ret, IntPtr.Zero, "GetInstalledAppsAsync(InstalledApplicationFilter) failed.");
+                }
                 return Result;
             });
         }
 
         internal async Task<IEnumerable<InstalledApplication>> GetInstalledAppsAsync(InstalledApplicationMetadataFilter filter)
         {
-            Console.WriteLine("GetInstalledAppsAsync(InstalledApplicationMetadataFilter filter)");
+            Log.Debug(LogTag, "GetInstalledAppsAsync(InstalledApplicationMetadataFilter filter)");
 
             return await Task.Run(() =>
             {
@@ -124,11 +143,15 @@ namespace Tizen.Applications.Managers
 
                 Interop.ApplicationManager.AppInfoFilterCallback cb = (IntPtr handle, IntPtr userData) =>
                 {
-                    Console.WriteLine("AppInfoFilterCallback");
+                    Log.Debug(LogTag, "AppInfoFilterCallback");
                     if (handle != IntPtr.Zero)
                     {
-                        IntPtr clonedHandle;
-                        Interop.ApplicationManager.AppInfoClone(out clonedHandle, handle);
+                        IntPtr clonedHandle = IntPtr.Zero;
+                        ret = Interop.ApplicationManager.AppInfoClone(out clonedHandle, handle);
+                        if (ret != 0)
+                        {
+                            ApplicationManagerErrorFactory.ExceptionChecker(ret, clonedHandle, "GetInstalledAppsAsync(InstalledApplicationMetadataFilter) failed.");
+                        }
                         InstalledApplication app = new InstalledApplication(clonedHandle);
                         Result.Add(app);
                         return true;
@@ -136,14 +159,18 @@ namespace Tizen.Applications.Managers
                     return false;
                 };
 
-                Interop.ApplicationManager.AppInfoMetadataFilterForeach(filter.Handle, cb, IntPtr.Zero);
+                ret = Interop.ApplicationManager.AppInfoMetadataFilterForeach(filter.Handle, cb, IntPtr.Zero);
+                if (ret != 0)
+                {
+                    ApplicationManagerErrorFactory.ExceptionChecker(ret, filter.Handle, "GetInstalledAppsAsync(InstalledApplicationMetadataFilter) failed.");
+                }
                 return Result;
             });
         }
 
         internal async Task<IEnumerable<RunningApplication>> GetRunningAppsAsync()
         {
-            Console.WriteLine("GetRunningAppsAsync()");
+            Log.Debug(LogTag, "GetRunningAppsAsync()");
 
             return await Task.Run(() =>
             {
@@ -151,14 +178,22 @@ namespace Tizen.Applications.Managers
 
                 Interop.ApplicationManager.AppManagerAppContextCallback cb = (IntPtr handle, IntPtr userData) =>
                 {
-                    Console.WriteLine("AppManagerAppContextCallback");
+                    Log.Debug(LogTag, "AppManagerAppContextCallback");
                     if (handle != IntPtr.Zero)
                     {
                         IntPtr ptr = IntPtr.Zero;
-                        Interop.ApplicationManager.AppContextGetAppId(handle, out ptr);
+                        ret = Interop.ApplicationManager.AppContextGetAppId(handle, out ptr);
+                        if (ret != 0)
+                        {
+                            ApplicationManagerErrorFactory.ExceptionChecker(ret, handle, "GetRunningAppsAsync() failed.");
+                        }
                         string appid = Marshal.PtrToStringAuto(ptr);
                         int pid = 0;
-                        Interop.ApplicationManager.AppContextGetPid(handle, out pid);
+                        ret = Interop.ApplicationManager.AppContextGetPid(handle, out pid);
+                        if (ret != 0)
+                        {
+                            ApplicationManagerErrorFactory.ExceptionChecker(ret, handle, "GetRunningAppsAsync() failed.");
+                        }
                         RunningApplication app = new RunningApplication(appid, pid);
                         Result.Add(app);
                         return true;
@@ -166,16 +201,24 @@ namespace Tizen.Applications.Managers
                     return false;
                 };
 
-                Interop.ApplicationManager.AppManagerForeachAppContext(cb, IntPtr.Zero);
+                ret = Interop.ApplicationManager.AppManagerForeachAppContext(cb, IntPtr.Zero);
+                if (ret != 0)
+                {
+                    ApplicationManagerErrorFactory.ExceptionChecker(ret, IntPtr.Zero, "GetRunningAppsAsync() failed.");
+                }
                 return Result;
             });
         }
 
         internal InstalledApplication GetInstalledApp(string applicationId)
         {
-            Console.WriteLine("GetInstalledApp(appid)");
+            Log.Debug(LogTag, "GetInstalledApp(applicationId)");
             IntPtr handle = IntPtr.Zero;
-            Interop.ApplicationManager.AppManagerGetAppInfo(applicationId, out handle);
+            ret = Interop.ApplicationManager.AppManagerGetAppInfo(applicationId, out handle);
+            if (ret != 0)
+            {
+                ApplicationManagerErrorFactory.ExceptionChecker(ret, handle, "GetInstalledApp(applicationId) failed.");
+            }
             if (handle != IntPtr.Zero)
             {
                 InstalledApplication app = new InstalledApplication(handle);
@@ -186,15 +229,21 @@ namespace Tizen.Applications.Managers
 
         internal RunningApplication GetRunningApp(string applicationId)
         {
-            Console.WriteLine("GetRunningApp(appid)");
+            Log.Debug(LogTag, "GetRunningApp(applicationId)");
             IntPtr handle = IntPtr.Zero;
-            Interop.ApplicationManager.AppManagerGetAppContext(applicationId, out handle);
-
+            ret = Interop.ApplicationManager.AppManagerGetAppContext(applicationId, out handle);
+            if (ret != 0)
+            {
+                ApplicationManagerErrorFactory.ExceptionChecker(ret, handle, "GetRunningApp(applicationId) failed.");
+            }
             if (handle != IntPtr.Zero)
             {
                 int pid = 0;
-                Interop.ApplicationManager.AppContextGetPid(handle, out pid);
-                Interop.ApplicationManager.AppContextDestroy(handle);
+                ret = Interop.ApplicationManager.AppContextGetPid(handle, out pid);
+                if (ret != 0)
+                {
+                    ApplicationManagerErrorFactory.ExceptionChecker(ret, handle, "GetRunningApp(applicationId) failed.");
+                }
                 RunningApplication app = new RunningApplication(applicationId, pid);
                 return app;
             }
@@ -203,51 +252,74 @@ namespace Tizen.Applications.Managers
 
         internal RunningApplication GetRunningApp(int processId)
         {
-            Console.WriteLine("GetRunningApp(pid)");
+            Log.Debug(LogTag, "GetRunningApp(processId)");
             string appid = "";
-            Interop.ApplicationManager.AppManagerGetAppId(processId, out appid);
+            ret = Interop.ApplicationManager.AppManagerGetAppId(processId, out appid);
+            if (ret != 0)
+            {
+                ApplicationManagerErrorFactory.ExceptionChecker(ret, IntPtr.Zero, "GetRunningApp(processId) failed.");
+            }
             RunningApplication app = new RunningApplication(appid, processId);
             return app;
         }
 
         internal bool IsRunningApp(string applicationId)
         {
-            Console.WriteLine("IsRunningApp(appid)");
+            Log.Debug(LogTag, "IsRunningApp(applicationId)");
             bool running = false;
-            Interop.ApplicationManager.AppManagerIsRunning(applicationId, out running);
+            ret = Interop.ApplicationManager.AppManagerIsRunning(applicationId, out running);
+            if (ret != 0)
+            {
+                Log.Warn(LogTag, "IsRunningApp(applicationId) failed.");
+            }
             return running;
         }
 
         internal bool IsRunningApp(int processId)
         {
-            Console.WriteLine("IsRunningApp(pid)");
+            Log.Debug(LogTag, "IsRunningApp(processId)");
             string appid = "";
-            Interop.ApplicationManager.AppManagerGetAppId(processId, out appid);
+            ret = Interop.ApplicationManager.AppManagerGetAppId(processId, out appid);
+            if (ret != 0)
+            {
+                ApplicationManagerErrorFactory.ExceptionChecker(ret, IntPtr.Zero, "IsRunningApp(processId) failed.");
+            }
             bool running = false;
-            Interop.ApplicationManager.AppManagerIsRunning(appid, out running);
+            ret = Interop.ApplicationManager.AppManagerIsRunning(appid, out running);
+            if (ret != 0)
+            {
+                Log.Warn(LogTag, "IsRunningApp(processId) failed.");
+            }
             return running;
         }
 
         private void RegisterApplicationChangedEvent()
         {
-            Console.WriteLine("RegisterApplicationChangedEvent()");
+            Log.Debug(LogTag, "RegisterApplicationChangedEvent()");
             _applicationChangedEventCallback = (IntPtr handle, int state, IntPtr userData) =>
             {
-                Console.WriteLine("ApplicationChangedEventCallback");
+                Log.Debug(LogTag, "ApplicationChangedEventCallback");
                 if (handle == IntPtr.Zero) return;
 
                 IntPtr ptr = IntPtr.Zero;
-                Interop.ApplicationManager.AppContextGetAppId(handle, out ptr);
+                ret = Interop.ApplicationManager.AppContextGetAppId(handle, out ptr);
+                if (ret != 0)
+                {
+                    ApplicationManagerErrorFactory.ExceptionChecker(ret, handle, "RegisterApplicationChangedEvent() failed.");
+                }
                 string appid = Marshal.PtrToStringAuto(ptr);
                 int pid = 0;
-                Interop.ApplicationManager.AppContextGetPid(handle, out pid);
-
+                ret = Interop.ApplicationManager.AppContextGetPid(handle, out pid);
+                if (ret != 0)
+                {
+                    ApplicationManagerErrorFactory.ExceptionChecker(ret, handle, "RegisterApplicationChangedEvent() failed.");
+                }
                 if (state == 0)
                 {
                     var launchedEventCache = ApplicationLaunched;
                     if (launchedEventCache != null)
                     {
-                        Console.WriteLine("Raise up ApplicationLaunched");
+                        Log.Debug(LogTag, "Raise up ApplicationLaunched");
                         ApplicationChangedEventArgs e = new ApplicationChangedEventArgs(appid, pid, state);
                         launchedEventCache(null, e);
                     }
@@ -257,19 +329,22 @@ namespace Tizen.Applications.Managers
                     var terminatedEventCache = ApplicationTerminated;
                     if (terminatedEventCache != null)
                     {
-                        Console.WriteLine("Raise up ApplicationTerminated");
+                        Log.Debug(LogTag, "Raise up ApplicationTerminated");
                         ApplicationChangedEventArgs e = new ApplicationChangedEventArgs(appid, pid, state);
                         terminatedEventCache(null, e);
                     }
                 }
             };
-
-            Interop.ApplicationManager.AppManagerSetAppContextEvent(_applicationChangedEventCallback, IntPtr.Zero);
+            ret = Interop.ApplicationManager.AppManagerSetAppContextEvent(_applicationChangedEventCallback, IntPtr.Zero);
+            if (ret != 0)
+            {
+                ApplicationManagerErrorFactory.ExceptionChecker(ret, IntPtr.Zero, "RegisterApplicationChangedEvent() register failed.");
+            }
         }
 
         private void UnRegisterApplicationChangedEvent()
         {
-            Console.WriteLine("UnRegisterApplicationChangedEvent()");
+            Log.Debug(LogTag, "UnRegisterApplicationChangedEvent()");
             Interop.ApplicationManager.AppManagerUnSetAppContextEvent();
         }
     }

diff --git a/Tizen.Applications/Tizen.Applications.Managers/InstalledApplication.cs b/Tizen.Applications/Tizen.Applications.Managers/InstalledApplication.cs
index 6df4be710dc2644d419c103fcbe59ff17eb448df..ba0d4709e360f61b5ed6afc7535fa26778aa5e5e 100755 (executable)
--- a/Tizen.Applications/Tizen.Applications.Managers/InstalledApplication.cs
+++ b/Tizen.Applications/Tizen.Applications.Managers/InstalledApplication.cs
@@ -20,6 +20,9 @@ namespace Tizen.Applications.Managers
         private IntPtr _handle;
         private bool disposed = false;
 
+        private const string LogTag = "Tizen.Applications.Managers";
+        private int ret = 0;
+
         internal InstalledApplication(IntPtr handle)
         {
             _handle = handle;
@@ -35,7 +38,15 @@ namespace Tizen.Applications.Managers
             {
                 IntPtr ptr = IntPtr.Zero;
                 Interop.ApplicationManager.AppInfoGetAppId(_handle, out ptr);
-                string appid = Marshal.PtrToStringAuto(ptr);
+                string appid = "";
+                if (ptr != IntPtr.Zero)
+                {
+                    appid = Marshal.PtrToStringAuto(ptr);
+                }
+                else
+                {
+                    Log.Warn(LogTag, "InstalledApplication get ApplicationId failed.");
+                }
                 return appid;
             }
         }
@@ -49,7 +60,15 @@ namespace Tizen.Applications.Managers
             {
                 IntPtr ptr = IntPtr.Zero;
                 Interop.ApplicationManager.AppInfoGetPackage(_handle, out ptr);
-                string packageid = Marshal.PtrToStringAuto(ptr);
+                string packageid = "";
+                if (ptr != IntPtr.Zero)
+                {
+                    packageid = Marshal.PtrToStringAuto(ptr);
+                }
+                else
+                {
+                    Log.Warn(LogTag, "InstalledApplication get PackageId failed.");
+                }
                 return packageid;
             }
         }
@@ -63,7 +82,15 @@ namespace Tizen.Applications.Managers
             {
                 IntPtr ptr = IntPtr.Zero;
                 Interop.ApplicationManager.AppInfoGetLabel(_handle, out ptr);
-                string label = Marshal.PtrToStringAuto(ptr);
+                string label = "";
+                if (ptr != IntPtr.Zero)
+                {
+                    label = Marshal.PtrToStringAuto(ptr);
+                }
+                else
+                {
+                    Log.Warn(LogTag, "InstalledApplication get Label failed.");
+                }
                 return label;
             }
         }
@@ -77,7 +104,15 @@ namespace Tizen.Applications.Managers
             {
                 IntPtr ptr = IntPtr.Zero;
                 Interop.ApplicationManager.AppInfoGetExec(_handle, out ptr);
-                string exec = Marshal.PtrToStringAuto(ptr);
+                string exec = "";
+                if (ptr != IntPtr.Zero)
+                {
+                    exec = Marshal.PtrToStringAuto(ptr);
+                }
+                else
+                {
+                    Log.Warn(LogTag, "InstalledApplication get ExcutablePath failed.");
+                }
                 return exec;
             }
         }
@@ -91,7 +126,15 @@ namespace Tizen.Applications.Managers
             {
                 IntPtr ptr = IntPtr.Zero;
                 Interop.ApplicationManager.AppInfoGetIcon(_handle, out ptr);
-                string path = Marshal.PtrToStringAuto(ptr);
+                string path = "";
+                if (ptr != IntPtr.Zero)
+                {
+                    path = Marshal.PtrToStringAuto(ptr);
+                }
+                else
+                {
+                    Log.Warn(LogTag, "InstalledApplication get IconPath failed.");
+                }
                 return path;
             }
         }
@@ -105,7 +148,15 @@ namespace Tizen.Applications.Managers
             {
                 IntPtr ptr = IntPtr.Zero;
                 Interop.ApplicationManager.AppInfoGetType(_handle, out ptr);
-                string type = Marshal.PtrToStringAuto(ptr);
+                string type = "";
+                if (ptr != IntPtr.Zero)
+                {
+                    type = Marshal.PtrToStringAuto(ptr);
+                }
+                else
+                {
+                    Log.Warn(LogTag, "InstalledApplication get Type failed.");
+                }
                 return type;
             }
         }
@@ -122,7 +173,7 @@ namespace Tizen.Applications.Managers
 
                 Interop.ApplicationManager.AppInfoMetadataCallback cb = (string key, string value, IntPtr userData) =>
                 {
-                    Console.WriteLine("AppInfoMetadataCallback");
+                    Log.Debug(LogTag, "AppInfoMetadataCallback");
                     if (key.Length != 0)
                     {
                         metadata.Add(key, value);
@@ -130,8 +181,11 @@ namespace Tizen.Applications.Managers
                     return true;
                 };
 
-                Interop.ApplicationManager.AppInfoForeachMetadata(_handle, cb, IntPtr.Zero);
-
+                ret = Interop.ApplicationManager.AppInfoForeachMetadata(_handle, cb, IntPtr.Zero);
+                if (ret != 0)
+                {
+                    Log.Warn(LogTag, "InstalledApplication get Metadata failed.");
+                }
                 return metadata;
             }
         }
@@ -183,7 +237,15 @@ namespace Tizen.Applications.Managers
         {
             IntPtr ptr = IntPtr.Zero;
             Interop.ApplicationManager.AppInfoGetLocaledLabel(ApplicationId, locale, out ptr);
-            string label = Marshal.PtrToStringAuto(ptr);
+            string label = Label;
+            if (ptr != IntPtr.Zero)
+            {
+                label = Marshal.PtrToStringAuto(ptr);
+            }
+            else
+            {
+                Log.Warn(LogTag, "InstalledApplication GetLocalizedLabel(" + locale + ") failed.");
+            }
             return label;
         }
 
@@ -193,7 +255,7 @@ namespace Tizen.Applications.Managers
         }
 
         /// <summary>
-        /// 
+        ///
         /// </summary>
         public void Dispose()
         {

diff --git a/Tizen.Applications/Tizen.Applications.Managers/InstalledApplicationFilter.cs b/Tizen.Applications/Tizen.Applications.Managers/InstalledApplicationFilter.cs
index 8510c17613354053ca8c6d9f8977bebc7b4d5e27..8f54666b87bf6516d8bfc3d8aba86563286ecd53 100755 (executable)
--- a/Tizen.Applications/Tizen.Applications.Managers/InstalledApplicationFilter.cs
+++ b/Tizen.Applications/Tizen.Applications.Managers/InstalledApplicationFilter.cs
@@ -46,23 +46,37 @@ namespace Tizen.Applications.Managers
         private IntPtr _handle;
         private bool disposed = false;
 
+        private const string LogTag = "Tizen.Applications.Managers";
+        private int ret = 0;
+
         public InstalledApplicationFilter(IDictionary<string, string> filter)
         {
-            Interop.ApplicationManager.AppInfoFilterCreate(out _handle);
+            ret = Interop.ApplicationManager.AppInfoFilterCreate(out _handle);
+            if (ret != 0)
+            {
+                ApplicationManagerErrorFactory.ExceptionChecker(ret, _handle, "InstalledApplicationFilter creation failed.");
+            }
             foreach (var item in filter)
             {
                 if ((item.Key == Keys.Id) || (item.Key == Keys.Type) || (item.Key == Keys.Category))
                 {
-                    Interop.ApplicationManager.AppInfoFilterAddString(_handle, item.Key, item.Value);
+                    ret = Interop.ApplicationManager.AppInfoFilterAddString(_handle, item.Key, item.Value);
+                    if (ret != 0)
+                    {
+                        ApplicationManagerErrorFactory.ExceptionChecker(ret, _handle, "InstalledApplicationFilter item add failed.");
+                    }
                 }
                 else if ((item.Key == Keys.NoDisplay) || (item.Key == Keys.TaskManage))
                 {
-                    Interop.ApplicationManager.AppInfoFilterAddBool(_handle, item.Key, Convert.ToBoolean(item.Value));
+                    ret = Interop.ApplicationManager.AppInfoFilterAddBool(_handle, item.Key, Convert.ToBoolean(item.Value));
+                    if (ret != 0)
+                    {
+                        ApplicationManagerErrorFactory.ExceptionChecker(ret, _handle, "InstalledApplicationFilter item add failed.");
+                    }
                 }
                 else
                 {
-                    // Not Supported Key
-                    Console.WriteLine(item.Key + " is NOT supported for the InstalledApplicationFilter");
+                    Log.Warn(LogTag, "InstalledApplicationFilter is NOT supported " + item.Key + " key.");
                 }
             }
         }

diff --git a/Tizen.Applications/Tizen.Applications.Managers/InstalledApplicationMetadataFilter.cs b/Tizen.Applications/Tizen.Applications.Managers/InstalledApplicationMetadataFilter.cs
index 132ba34c4aa6289d98565d6023e5d16ec4917456..c75158f608a2178dfb47eb4386685c0eb30792d7 100755 (executable)
--- a/Tizen.Applications/Tizen.Applications.Managers/InstalledApplicationMetadataFilter.cs
+++ b/Tizen.Applications/Tizen.Applications.Managers/InstalledApplicationMetadataFilter.cs
@@ -19,12 +19,23 @@ namespace Tizen.Applications.Managers
         private IntPtr _handle;
         private bool disposed = false;
 
+        private const string LogTag = "Tizen.Applications.Managers";
+        private int ret = 0;
+
         public InstalledApplicationMetadataFilter(IDictionary<string, string> filter)
         {
-            Interop.ApplicationManager.AppInfoMetadataFilterCreate(out _handle);
+            ret = Interop.ApplicationManager.AppInfoMetadataFilterCreate(out _handle);
+            if (ret != 0)
+            {
+                ApplicationManagerErrorFactory.ExceptionChecker(ret, _handle, "InstalledApplicationMetadataFilter creation failed.");
+            }
             foreach (var item in filter)
             {
-                Interop.ApplicationManager.AppInfoMetadataFilterAdd(_handle, item.Key, item.Value);
+                ret = Interop.ApplicationManager.AppInfoMetadataFilterAdd(_handle, item.Key, item.Value);
+                if (ret != 0)
+                {
+                    ApplicationManagerErrorFactory.ExceptionChecker(ret, _handle, "InstalledApplicationMetadataFilter item add failed.");
+                }
             }
         }
 

diff --git a/Tizen.Applications/Tizen.Applications.csproj b/Tizen.Applications/Tizen.Applications.csproj
index c3959b38273433fb4c070194cb93ab6be8f096d8..89edf726514215f8f6cae959309214da686821bf 100755 (executable)
--- a/Tizen.Applications/Tizen.Applications.csproj
+++ b/Tizen.Applications/Tizen.Applications.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
@@ -60,6 +60,7 @@
     <Compile Include="Interop\Interop.MessagePort.cs" />
     <Compile Include="Interop\Interop.Service.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Tizen.Applications.Managers\ApplicationManagerErrorFactory.cs" />
     <Compile Include="Tizen.Applications.Managers\ApplicationState.cs" />
     <Compile Include="Tizen.Applications.Managers\InstalledApplicationMetadataFilter.cs" />
     <Compile Include="Tizen.Applications.Messages\MessagePort.cs" />