src/Tizen.Applications.Common/Tizen.Applications/ApplicationInfo.cs

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using System;
  18 using System.Collections.Generic;
  19
  20 namespace Tizen.Applications
  21 {
  22     /// <summary>
  23     /// This class provides methods and properties to get information of the application.
  24     /// </summary>
  25     /// <since_tizen> 3 </since_tizen>
  26     public class ApplicationInfo : IDisposable
  27     {
  28         private const string LogTag = "Tizen.Applications";
  29         private bool _disposed = false;
  30         private IntPtr _infoHandle = IntPtr.Zero;
  31         private string _applicationId = string.Empty;
  32         private Interop.ApplicationManager.ErrorCode err = Interop.ApplicationManager.ErrorCode.None;
  33
  34         internal ApplicationInfo(IntPtr infoHandle)
  35         {
  36             err = Interop.ApplicationManager.AppInfoGetAppId(infoHandle, out _applicationId);
  37             if (err != Interop.ApplicationManager.ErrorCode.None)
  38             {
  39                 throw new ArgumentException("Invalid native handle.");
  40             }
  41             _infoHandle = infoHandle;
  42         }
  43
  44         /// <summary>
  45         /// A constructor of ApplicationInfo that takes the application ID.
  46         /// </summary>
  47         /// <param name="applicationId">Application ID.</param>
  48         /// <since_tizen> 3 </since_tizen>
  49         public ApplicationInfo(string applicationId)
  50         {
  51             _applicationId = applicationId;
  52         }
  53
  54         /// <summary>
  55         /// Destructor of the class.
  56         /// </summary>
  57         ~ApplicationInfo()
  58         {
  59             Dispose(false);
  60         }
  61
  62         /// <summary>
  63         /// Gets the application ID.
  64         /// </summary>
  65         /// <since_tizen> 3 </since_tizen>
  66         public string ApplicationId
  67         {
  68             get
  69             {
  70                 if (!string.IsNullOrEmpty(_applicationId))
  71                     return _applicationId;
  72                 IntPtr infoHandle = GetInfoHandle();
  73                 string appid = string.Empty;
  74                 if (infoHandle != IntPtr.Zero)
  75                 {
  76                     err = Interop.ApplicationManager.AppInfoGetAppId(infoHandle, out appid);
  77                     if (err != Interop.ApplicationManager.ErrorCode.None)
  78                     {
  79                         Log.Warn(LogTag, "Failed to get the application id. err = " + err);
  80                     }
  81                 }
  82                 return appid;
  83             }
  84         }
  85
  86         /// <summary>
  87         /// Gets the package ID of the application.
  88         /// </summary>
  89         /// <since_tizen> 3 </since_tizen>
  90         public string PackageId
  91         {
  92             get
  93             {
  94                 IntPtr infoHandle = GetInfoHandle();
  95                 string packageid = string.Empty;
  96                 if (infoHandle != IntPtr.Zero)
  97                 {
  98                     err = Interop.ApplicationManager.AppInfoGetPackage(infoHandle, out packageid);
  99                     if (err != Interop.ApplicationManager.ErrorCode.None)
 100                     {
 101                         Log.Warn(LogTag, "Failed to get the package id of " + _applicationId + ". err = " + err);
 102                     }
 103                 }
 104                 return packageid;
 105             }
 106         }
 107
 108         /// <summary>
 109         /// Gets the label of the application.
 110         /// </summary>
 111         /// <since_tizen> 3 </since_tizen>
 112         public string Label
 113         {
 114             get
 115             {
 116                 IntPtr infoHandle = GetInfoHandle();
 117                 string label = string.Empty;
 118                 if (infoHandle != IntPtr.Zero)
 119                 {
 120                     err = Interop.ApplicationManager.AppInfoGetLabel(infoHandle, out label);
 121                     if (err != Interop.ApplicationManager.ErrorCode.None)
 122                     {
 123                         Log.Warn(LogTag, "Failed to get the app label of " + _applicationId + ". err = " + err);
 124                     }
 125                 }
 126                 return label;
 127             }
 128         }
 129
 130         /// <summary>
 131         /// Gets the executable path of the application.
 132         /// </summary>
 133         /// <since_tizen> 3 </since_tizen>
 134         public string ExecutablePath
 135         {
 136             get
 137             {
 138                 IntPtr infoHandle = GetInfoHandle();
 139                 string exec = string.Empty;
 140                 if (infoHandle != IntPtr.Zero)
 141                 {
 142                     err = Interop.ApplicationManager.AppInfoGetExec(infoHandle, out exec);
 143                     if (err != Interop.ApplicationManager.ErrorCode.None)
 144                     {
 145                         Log.Warn(LogTag, "Failed to get the executable file path of " + _applicationId + ". err = " + err);
 146                     }
 147                 }
 148                 return exec;
 149             }
 150         }
 151
 152         /// <summary>
 153         /// Gets the absolute path to the icon image.
 154         /// </summary>
 155         /// <since_tizen> 3 </since_tizen>
 156         public string IconPath
 157         {
 158             get
 159             {
 160                 IntPtr infoHandle = GetInfoHandle();
 161                 string path = string.Empty;
 162                 if (infoHandle != IntPtr.Zero)
 163                 {
 164                     err = Interop.ApplicationManager.AppInfoGetIcon(infoHandle, out path);
 165                     if (err != Interop.ApplicationManager.ErrorCode.None)
 166                     {
 167                         Log.Warn(LogTag, "Failed to get the app icon path of " + _applicationId + ". err = " + err);
 168                     }
 169                 }
 170                 return path;
 171             }
 172         }
 173
 174         /// <summary>
 175         /// Gets the application type name.
 176         /// </summary>
 177         /// <since_tizen> 3 </since_tizen>
 178         public string ApplicationType
 179         {
 180             get
 181             {
 182                 IntPtr infoHandle = GetInfoHandle();
 183                 string type = string.Empty;
 184                 if (infoHandle != IntPtr.Zero)
 185                 {
 186                     err = Interop.ApplicationManager.AppInfoGetType(infoHandle, out type);
 187                     if (err != Interop.ApplicationManager.ErrorCode.None)
 188                     {
 189                         Log.Warn(LogTag, "Failed to get the application type of " + _applicationId + ". err = " + err);
 190                     }
 191                 }
 192                 return type;
 193             }
 194         }
 195
 196         /// <summary>
 197         /// Gets the application's metadata.
 198         /// </summary>
 199         /// <since_tizen> 3 </since_tizen>
 200         public IDictionary<String, String> Metadata
 201         {
 202             get
 203             {
 204                 IDictionary<string, string> metadata = new Dictionary<String, String>();
 205
 206                 Interop.ApplicationManager.AppInfoMetadataCallback cb = (string key, string value, IntPtr userData) =>
 207                 {
 208                     if (key.Length != 0)
 209                     {
 210                         metadata.Add(key, value);
 211                     }
 212                     return true;
 213                 };
 214
 215                 IntPtr infoHandle = GetInfoHandle();
 216                 if (infoHandle != IntPtr.Zero)
 217                 {
 218                     err = Interop.ApplicationManager.AppInfoForeachMetadata(infoHandle, cb, IntPtr.Zero);
 219                     if (err != Interop.ApplicationManager.ErrorCode.None)
 220                     {
 221                         Log.Warn(LogTag, "Failed to get application metadata of " + _applicationId + ". err = " + err);
 222                     }
 223                 }
 224                 return metadata;
 225             }
 226         }
 227
 228         /// <summary>
 229         /// Checks whether the application information is nodisplay. If the application icon is not displayed on the menu screen, true; otherwise, false.
 230         /// </summary>
 231         /// <since_tizen> 3 </since_tizen>
 232         public bool IsNoDisplay
 233         {
 234             get
 235             {
 236                 IntPtr infoHandle = GetInfoHandle();
 237                 bool nodisplay = false;
 238                 if (infoHandle != IntPtr.Zero)
 239                 {
 240                     err = Interop.ApplicationManager.AppInfoIsNodisplay(infoHandle, out nodisplay);
 241                     if (err != Interop.ApplicationManager.ErrorCode.None)
 242                     {
 243                         Log.Warn(LogTag, "Failed to get the IsNoDisplay value of " + _applicationId + ". err = " + err);
 244
 245                     }
 246                 }
 247                 return nodisplay;
 248             }
 249         }
 250
 251         /// <summary>
 252         /// Checks whether the application is launched on booting time. If the application automatically starts on boot, true; otherwise, false.
 253         /// </summary>
 254         /// <since_tizen> 3 </since_tizen>
 255         public bool IsOnBoot
 256         {
 257             get
 258             {
 259                 IntPtr infoHandle = GetInfoHandle();
 260                 bool onboot = false;
 261                 if (infoHandle != IntPtr.Zero)
 262                 {
 263                     err = Interop.ApplicationManager.AppInfoIsOnBoot(infoHandle, out onboot);
 264                     if (err != Interop.ApplicationManager.ErrorCode.None)
 265                     {
 266                         Log.Warn(LogTag, "Failed to get the IsOnBoot value of " + _applicationId + ". err = " + err);
 267                     }
 268                 }
 269                 return onboot;
 270             }
 271         }
 272
 273         /// <summary>
 274         /// Checks whether the application is preloaded. If the application is preloaded, true; otherwise, false.
 275         /// </summary>
 276         /// <since_tizen> 3 </since_tizen>
 277         public bool IsPreload
 278         {
 279             get
 280             {
 281                 IntPtr infoHandle = GetInfoHandle();
 282                 bool preloaded = false;
 283                 if (infoHandle != IntPtr.Zero)
 284                 {
 285                     err = Interop.ApplicationManager.AppInfoIsPreLoad(infoHandle, out preloaded);
 286                     if (err != Interop.ApplicationManager.ErrorCode.None)
 287                     {
 288                         Log.Warn(LogTag, "Failed to get the IsPreload value of " + _applicationId + ". err = " + err);
 289                     }
 290                 }
 291                 return preloaded;
 292             }
 293         }
 294
 295         /// <summary>
 296         /// Gets the shared data path.
 297         /// </summary>
 298         /// <remarks>
 299         /// An application that wants to use shared/data directory must declare http://tizen.org/privilege/appdir.shareddata privilege. If the application doesn't declare the privilege, the framework will not create shared/data directory for the application. This property will return empty string when the application doesn't have shared/data directory.
 300         /// </remarks>
 301         /// <since_tizen> 3 </since_tizen>
 302         public string SharedDataPath
 303         {
 304             get
 305             {
 306                 string path = string.Empty;
 307                 err = Interop.ApplicationManager.AppManagerGetSharedDataPath(ApplicationId, out path);
 308                 if (err != Interop.ApplicationManager.ErrorCode.None)
 309                 {
 310                     Log.Warn(LogTag, "Failed to get the SharedDataPath of " + _applicationId + ". err = " + err);
 311                 }
 312                 return path;
 313             }
 314         }
 315
 316         /// <summary>
 317         /// Gets the shared resource path.
 318         /// </summary>
 319         /// <since_tizen> 3 </since_tizen>
 320         public string SharedResourcePath
 321         {
 322             get
 323             {
 324                 string path = string.Empty;
 325                 err = Interop.ApplicationManager.AppManagerGetSharedResourcePath(ApplicationId, out path);
 326                 if (err != Interop.ApplicationManager.ErrorCode.None)
 327                 {
 328                     Log.Warn(LogTag, "Failed to get the SharedResourcePath of " + _applicationId + ". err = " + err);
 329                 }
 330                 return path;
 331             }
 332         }
 333
 334         /// <summary>
 335         /// Gets the shared trust path.
 336         /// </summary>
 337         /// <since_tizen> 3 </since_tizen>
 338         public string SharedTrustedPath
 339         {
 340             get
 341             {
 342                 string path = string.Empty;
 343                 err = Interop.ApplicationManager.AppManagerGetSharedTrustedPath(ApplicationId, out path);
 344                 if (err != Interop.ApplicationManager.ErrorCode.None)
 345                 {
 346                     Log.Warn(LogTag, "Failed to get the SharedTrustedPath of " + _applicationId + ". err = " + err);
 347                 }
 348                 return path;
 349             }
 350         }
 351
 352         /// <summary>
 353         /// Gets the external shared data path.
 354         /// </summary>
 355         /// <since_tizen> 3 </since_tizen>
 356         public string ExternalSharedDataPath
 357         {
 358             get
 359             {
 360                 string path = string.Empty;
 361                 err = Interop.ApplicationManager.AppManagerGetExternalSharedDataPath(ApplicationId, out path);
 362                 if (err != Interop.ApplicationManager.ErrorCode.None)
 363                 {
 364                     Log.Warn(LogTag, "Failed to get the ExternalSharedDataPath of " + _applicationId + ". err = " + err);
 365                 }
 366                 return path;
 367             }
 368         }
 369
 370         /// <summary>
 371         /// Gets the localized label of the application for the given locale.
 372         /// </summary>
 373         /// <param name="locale">Locale.</param>
 374         /// <since_tizen> 3 </since_tizen>
 375         public string GetLocalizedLabel(string locale)
 376         {
 377             string label = string.Empty;
 378             err = Interop.ApplicationManager.AppInfoGetLocaledLabel(ApplicationId, locale, out label);
 379             if (err != Interop.ApplicationManager.ErrorCode.None)
 380             {
 381                 Log.Warn(LogTag, "Failed to get the GetLocalizedLabel of " + _applicationId + ". err = " + err);
 382                 label = Label;
 383             }
 384             return label;
 385         }
 386
 387         private IntPtr GetInfoHandle()
 388         {
 389             if (_infoHandle == IntPtr.Zero)
 390             {
 391                 IntPtr infoHandle = IntPtr.Zero;
 392                 err = Interop.ApplicationManager.AppManagerGetAppInfo(_applicationId, out infoHandle);
 393                 if (err != Interop.ApplicationManager.ErrorCode.None)
 394                 {
 395                     Log.Warn(LogTag, "Failed to get the handle of the ApplicationInfo. err = " + err);
 396                 }
 397                 _infoHandle = infoHandle;
 398             }
 399             return _infoHandle;
 400         }
 401
 402         /// <summary>
 403         /// Releases all resources used by the ApplicationInfo class.
 404         /// </summary>
 405         /// <since_tizen> 3 </since_tizen>
 406         public void Dispose()
 407         {
 408             Dispose(true);
 409             GC.SuppressFinalize(this);
 410         }
 411
 412         private void Dispose(bool disposing)
 413         {
 414             if (_disposed)
 415                 return;
 416             if (disposing)
 417             {
 418             }
 419             if (_infoHandle != IntPtr.Zero)
 420             {
 421                 Interop.ApplicationManager.AppInfoDestroy(_infoHandle);
 422                 _infoHandle = IntPtr.Zero;
 423             }
 424             _disposed = true;
 425         }
 426     }
 427 }