src/Tizen.Applications.Common/Tizen.Applications/CoreApplication.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.Concurrent;
  19 using System.ComponentModel;
  20 using System.Globalization;
  21 using System.Runtime.InteropServices;
  22 using System.Text;
  23 using System.Threading;
  24 using System.Threading.Tasks;
  25 using System.Timers;
  26 using Tizen.Applications.CoreBackend;
  27
  28 namespace Tizen.Applications
  29 {
  30     /// <summary>
  31     /// This class represents an application controlled lifecycles by the backend system.
  32     /// </summary>
  33     /// <since_tizen> 3 </since_tizen>
  34     public class CoreApplication : Application
  35     {
  36         private readonly ICoreBackend _backend;
  37         private readonly ICoreTask _task;
  38         private bool _disposedValue = false;
  39
  40         private static System.Timers.Timer sTimer;
  41
  42         /// <summary>
  43         /// Initializes the CoreApplication class.
  44         /// </summary>
  45         /// <param name="backend">The backend instance implementing ICoreBacked interface.</param>
  46         /// <since_tizen> 3 </since_tizen>
  47         public CoreApplication(ICoreBackend backend)
  48         {
  49             _backend = backend;
  50             _task = null;
  51         }
  52
  53         /// <summary>
  54         /// Initializes the CoreApplication class.
  55         /// </summary>
  56         /// <param name="backend">The backend instance implementing ICoreBackend interface.</param>
  57         /// <param name="task">The backend instance implmenting ICoreTask interface.</param>
  58         /// <since_tizen> 10 </since_tizen>
  59         [EditorBrowsable(EditorBrowsableState.Never)]
  60         public CoreApplication(ICoreBackend backend, ICoreTask task)
  61         {
  62             _backend = backend;
  63             _task = task;
  64         }
  65
  66         /// <summary>
  67         /// Occurs when the application is launched.
  68         /// </summary>
  69         /// <since_tizen> 3 </since_tizen>
  70         public event EventHandler Created;
  71
  72         /// <summary>
  73         /// Occurs when the application is about to shutdown.
  74         /// </summary>
  75         /// <since_tizen> 3 </since_tizen>
  76         public event EventHandler Terminated;
  77
  78         /// <summary>
  79         /// Occurs whenever the application receives the appcontrol message.
  80         /// </summary>
  81         /// <since_tizen> 3 </since_tizen>
  82         public event EventHandler<AppControlReceivedEventArgs> AppControlReceived;
  83
  84         /// <summary>
  85         /// Occurs when the system memory is low.
  86         /// </summary>
  87         /// <since_tizen> 3 </since_tizen>
  88         public event EventHandler<LowMemoryEventArgs> LowMemory;
  89
  90         /// <summary>
  91         /// Occurs when the system battery is low.
  92         /// </summary>
  93         /// <since_tizen> 3 </since_tizen>
  94         public event EventHandler<LowBatteryEventArgs> LowBattery;
  95
  96         /// <summary>
  97         /// Occurs when the system language is chagned.
  98         /// </summary>
  99         /// <since_tizen> 3 </since_tizen>
 100         public event EventHandler<LocaleChangedEventArgs> LocaleChanged;
 101
 102         /// <summary>
 103         /// Occurs when the region format is changed.
 104         /// </summary>
 105         /// <since_tizen> 3 </since_tizen>
 106         public event EventHandler<RegionFormatChangedEventArgs> RegionFormatChanged;
 107
 108         /// <summary>
 109         /// Occurs when the device orientation is changed.
 110         /// </summary>
 111         /// <since_tizen> 3 </since_tizen>
 112         public event EventHandler<DeviceOrientationEventArgs> DeviceOrientationChanged;
 113
 114         /// <summary>
 115         /// The backend instance.
 116         /// </summary>
 117         /// <since_tizen> 3 </since_tizen>
 118         protected ICoreBackend Backend { get { return _backend; } }
 119
 120         /// <summary>
 121         /// Runs the application's main loop.
 122         /// </summary>
 123         /// <param name="args">Arguments from commandline.</param>
 124         /// <since_tizen> 3 </since_tizen>
 125         public override void Run(string[] args)
 126         {
 127             base.Run(args);
 128
 129             _backend.AddEventHandler(EventType.Created, OnCreate);
 130             _backend.AddEventHandler(EventType.Terminated, OnTerminate);
 131             _backend.AddEventHandler<AppControlReceivedEventArgs>(EventType.AppControlReceived, OnAppControlReceived);
 132             _backend.AddEventHandler<LowMemoryEventArgs>(EventType.LowMemory, OnLowMemory);
 133             _backend.AddEventHandler<LowBatteryEventArgs>(EventType.LowBattery, OnLowBattery);
 134             _backend.AddEventHandler<LocaleChangedEventArgs>(EventType.LocaleChanged, OnLocaleChanged);
 135             _backend.AddEventHandler<RegionFormatChangedEventArgs>(EventType.RegionFormatChanged, OnRegionFormatChanged);
 136             _backend.AddEventHandler<DeviceOrientationEventArgs>(EventType.DeviceOrientationChanged, OnDeviceOrientationChanged);
 137
 138             string[] argsClone = new string[args == null ? 1 : args.Length + 1];
 139             if (args != null && args.Length > 1)
 140             {
 141                 args.CopyTo(argsClone, 1);
 142             }
 143             argsClone[0] = string.Empty;
 144
 145             if (_task != null)
 146             {
 147                 ICoreTaskBackend backend = (ICoreTaskBackend)_backend;
 148                 backend.SetCoreTask(_task);
 149                 backend.Run(argsClone);
 150             }
 151             else
 152             {
 153                 _backend.Run(argsClone);
 154             }
 155         }
 156
 157         /// <summary>
 158         /// Exits the main loop of the application.
 159         /// </summary>
 160         /// <since_tizen> 3 </since_tizen>
 161         public override void Exit()
 162         {
 163             _backend.Exit();
 164         }
 165
 166         /// <summary>
 167         /// Overrides this method if want to handle behavior when the application is launched.
 168         /// If base.OnCreated() is not called, the event 'Created' will not be emitted.
 169         /// </summary>
 170         /// <since_tizen> 3 </since_tizen>
 171         protected virtual void OnCreate()
 172         {
 173             if (_task != null)
 174             {
 175                 TizenUISynchronizationContext.Initialize();
 176             }
 177
 178             if (!GlobalizationMode.Invariant)
 179             {
 180                 string locale = ULocale.GetDefaultLocale();
 181                 ChangeCurrentUICultureInfo(locale);
 182                 ChangeCurrentCultureInfo(locale);
 183             }
 184             else
 185             {
 186                 Log.Warn(LogTag, "Run in invariant mode");
 187             }
 188
 189             Created?.Invoke(this, EventArgs.Empty);
 190         }
 191
 192         /// <summary>
 193         /// Overrides this method if want to handle behavior when the application is terminated.
 194         /// If base.OnTerminate() is not called, the event 'Terminated' will not be emitted.
 195         /// </summary>
 196         /// <since_tizen> 3 </since_tizen>
 197         protected virtual void OnTerminate()
 198         {
 199             Terminated?.Invoke(this, EventArgs.Empty);
 200         }
 201
 202         /// <summary>
 203         /// Overrides this method if want to handle behavior when the application receives the appcontrol message.
 204         /// If base.OnAppControlReceived() is not called, the event 'AppControlReceived' will not be emitted.
 205         /// </summary>
 206         /// <param name="e"></param>
 207         /// <since_tizen> 3 </since_tizen>
 208         protected virtual void OnAppControlReceived(AppControlReceivedEventArgs e)
 209         {
 210             AppControlReceived?.Invoke(this, e);
 211         }
 212
 213         /// <summary>
 214         /// Overrides this method if want to handle behavior when the system memory is low.
 215         /// If base.OnLowMemory() is not called, the event 'LowMemory' will not be emitted.
 216         /// </summary>
 217         /// <param name="e">The low memory event argument</param>
 218         /// <since_tizen> 3 </since_tizen>
 219         protected virtual void OnLowMemory(LowMemoryEventArgs e)
 220         {
 221             LowMemory?.Invoke(this, e);
 222             if (e.LowMemoryStatus == LowMemoryStatus.SoftWarning || e.LowMemoryStatus == LowMemoryStatus.HardWarning)
 223             {
 224                 System.GC.Collect();
 225             }
 226         }
 227
 228         /// <summary>
 229         /// Overrides this method if want to handle behavior when the system battery is low.
 230         /// If base.OnLowBattery() is not called, the event 'LowBattery' will not be emitted.
 231         /// </summary>
 232         /// <param name="e">The low battery event argument</param>
 233         /// <since_tizen> 3 </since_tizen>
 234         protected virtual void OnLowBattery(LowBatteryEventArgs e)
 235         {
 236             LowBattery?.Invoke(this, e);
 237         }
 238
 239         /// <summary>
 240         /// Overrides this method if want to handle behavior when the system language is changed.
 241         /// If base.OnLocaleChanged() is not called, the event 'LocaleChanged' will not be emitted.
 242         /// </summary>
 243         /// <param name="e">The locale changed event argument</param>
 244         /// <since_tizen> 3 </since_tizen>
 245         protected virtual void OnLocaleChanged(LocaleChangedEventArgs e)
 246         {
 247             if (!GlobalizationMode.Invariant)
 248             {
 249                 ChangeCurrentUICultureInfo(e.Locale);
 250             }
 251
 252             LocaleChanged?.Invoke(this, e);
 253         }
 254
 255         /// <summary>
 256         /// Overrides this method if want to handle behavior when the region format is changed.
 257         /// If base.OnRegionFormatChanged() is not called, the event 'RegionFormatChanged' will not be emitted.
 258         /// </summary>
 259         /// <param name="e">The region format changed event argument</param>
 260         /// <since_tizen> 3 </since_tizen>
 261         protected virtual void OnRegionFormatChanged(RegionFormatChangedEventArgs e)
 262         {
 263             if (!GlobalizationMode.Invariant)
 264             {
 265                 ChangeCurrentCultureInfo(e.Region);
 266             }
 267
 268             RegionFormatChanged?.Invoke(this, e);
 269         }
 270
 271         /// <summary>
 272         /// Overrides this method if want to handle behavior when the device orientation is changed.
 273         /// If base.OnRegionFormatChanged() is not called, the event 'RegionFormatChanged' will not be emitted.
 274         /// </summary>
 275         /// <param name="e">The device orientation changed event argument</param>
 276         /// <since_tizen> 3 </since_tizen>
 277         protected virtual void OnDeviceOrientationChanged(DeviceOrientationEventArgs e)
 278         {
 279             DeviceOrientationChanged?.Invoke(this, e);
 280         }
 281
 282         /// <summary>
 283         /// Dispatches an asynchronous message to the main loop of the CoreTask.
 284         /// </summary>
 285         /// <param name="runner">The runner callaback.</param>
 286         /// <exception cref="ArgumentNullException">Thrown when the runner is null.</exception>
 287         /// <since_tizen> 10 </since_tizen>
 288         [EditorBrowsable(EditorBrowsableState.Never)]
 289         public void Post(Action runner)
 290         {
 291             if (runner == null)
 292             {
 293                 throw new ArgumentNullException(nameof(runner));
 294             }
 295
 296             GSourceManager.Post(runner);
 297         }
 298
 299         /// <summary>
 300         /// Dispatches an asynchronous message to the main loop of the CoreTask.
 301         /// </summary>
 302         /// <typeparam name="T">The type of the result.</typeparam>
 303         /// <param name="runner">The runner callback.</param>
 304         /// <exception cref="ArgumentNullException">Thrown when the runner is null.</exception>
 305         /// <returns>A task with the result.</returns>
 306         /// <since_tizen> 10 </since_tizen>
 307         [EditorBrowsable(EditorBrowsableState.Never)]
 308         public async Task<T> Post<T>(Func<T> runner)
 309         {
 310             if (runner == null)
 311             {
 312                 throw new ArgumentNullException(nameof(runner));
 313             }
 314
 315             var task = new TaskCompletionSource<T>();
 316             GSourceManager.Post(() => { task.SetResult(runner()); });
 317             return await task.Task.ConfigureAwait(false);
 318         }
 319
 320         /// <summary>
 321         /// Releases any unmanaged resources used by this object. Can also dispose any other disposable objects.
 322         /// </summary>
 323         /// <param name="disposing">If true, disposes any disposable objects. If false, does not dispose disposable objects.</param>
 324         /// <since_tizen> 3 </since_tizen>
 325         protected override void Dispose(bool disposing)
 326         {
 327             if (!_disposedValue)
 328             {
 329                 if (disposing)
 330                 {
 331                     _backend.Dispose();
 332                 }
 333
 334                 _disposedValue = true;
 335             }
 336             base.Dispose(disposing);
 337         }
 338
 339         private CultureInfo ConvertCultureInfo(string locale)
 340         {
 341             ULocale pLocale = new ULocale(locale);
 342             string cultureName = CultureInfoHelper.GetCultureName(pLocale.Locale.Replace("_", "-"));
 343
 344             if (!string.IsNullOrEmpty(cultureName))
 345             {
 346                 try
 347                 {
 348                     return new CultureInfo(cultureName);
 349                 }
 350                 catch (CultureNotFoundException)
 351                 {
 352                     Log.Error(LogTag, "CultureNotFoundException occurs. CultureName: " + cultureName);
 353                 }
 354             }
 355
 356             try
 357             {
 358                 return new CultureInfo(pLocale.LCID);
 359             }
 360             catch (ArgumentOutOfRangeException)
 361             {
 362                 return GetFallbackCultureInfo(pLocale);
 363             }
 364             catch (CultureNotFoundException)
 365             {
 366                 return GetFallbackCultureInfo(pLocale);
 367             }
 368         }
 369
 370         private void ChangeCurrentCultureInfo(string locale)
 371         {
 372             CultureInfo cultureInfo = ConvertCultureInfo(locale);
 373             if (cultureInfo != null)
 374             {
 375                 CultureInfo.CurrentCulture = cultureInfo;
 376             }
 377             else
 378             {
 379                 Log.Error(LogTag, "CultureInfo is null. locale: " + locale);
 380             }
 381         }
 382
 383         private void ChangeCurrentUICultureInfo(string locale)
 384         {
 385             CultureInfo cultureInfo = ConvertCultureInfo(locale);
 386             if (cultureInfo != null)
 387             {
 388                 CultureInfo.CurrentUICulture = cultureInfo;
 389             }
 390             else
 391             {
 392                 Log.Error(LogTag, "CultureInfo is null. locale: " + locale);
 393             }
 394         }
 395
 396         private bool ExistCultureInfo(string locale)
 397         {
 398             foreach (var cultureInfo in CultureInfo.GetCultures(CultureTypes.AllCultures))
 399             {
 400                 if (cultureInfo.Name == locale)
 401                 {
 402                     return true;
 403                 }
 404             }
 405
 406             return false;
 407         }
 408
 409         private CultureInfo GetCultureInfo(string locale)
 410         {
 411             if (!ExistCultureInfo(locale))
 412             {
 413                 return null;
 414             }
 415
 416             try
 417             {
 418                 return new CultureInfo(locale);
 419             }
 420             catch (CultureNotFoundException)
 421             {
 422                 return null;
 423             }
 424         }
 425
 426         private CultureInfo GetFallbackCultureInfo(ULocale uLocale)
 427         {
 428             CultureInfo fallbackCultureInfo = null;
 429             string locale = string.Empty;
 430
 431             if (uLocale.Locale != null)
 432             {
 433                 locale = uLocale.Locale.Replace("_", "-");
 434                 fallbackCultureInfo = GetCultureInfo(locale);
 435             }
 436
 437             if (fallbackCultureInfo == null && uLocale.Language != null && uLocale.Script != null && uLocale.Country != null)
 438             {
 439                 locale = uLocale.Language + "-" + uLocale.Script + "-" + uLocale.Country;
 440                 fallbackCultureInfo = GetCultureInfo(locale);
 441             }
 442
 443             if (fallbackCultureInfo == null && uLocale.Language != null && uLocale.Script != null)
 444             {
 445                 locale = uLocale.Language + "-" + uLocale.Script;
 446                 fallbackCultureInfo = GetCultureInfo(locale);
 447             }
 448
 449             if (fallbackCultureInfo == null && uLocale.Language != null && uLocale.Country != null)
 450             {
 451                 locale = uLocale.Language + "-" + uLocale.Country;
 452                 fallbackCultureInfo = GetCultureInfo(locale);
 453             }
 454
 455             if (fallbackCultureInfo == null && uLocale.Language != null)
 456             {
 457                 locale = uLocale.Language;
 458                 fallbackCultureInfo = GetCultureInfo(locale);
 459             }
 460
 461             if (fallbackCultureInfo == null)
 462             {
 463                 try
 464                 {
 465                     fallbackCultureInfo = new CultureInfo("en");
 466                 }
 467                 catch (CultureNotFoundException e)
 468                 {
 469                     Log.Error(LogTag, "Failed to create CultureInfo. err = " + e.Message);
 470                 }
 471             }
 472
 473             return fallbackCultureInfo;
 474         }
 475     }
 476
 477     internal static class GlobalizationMode
 478     {
 479         private static int _invariant = -1;
 480
 481         internal static bool Invariant
 482         {
 483             get
 484             {
 485                 if (_invariant == -1)
 486                 {
 487                     string value = Environment.GetEnvironmentVariable("DOTNET_SYSTEM_GLOBALIZATION_INVARIANT");
 488                     _invariant = value != null ? (value.Equals("1") ? 1 : 0) : 0;
 489                 }
 490
 491                 return _invariant != 0;
 492             }
 493         }
 494     }
 495
 496     internal class ULocale
 497     {
 498         private const int ULOC_FULLNAME_CAPACITY = 157;
 499         private const int ULOC_LANG_CAPACITY = 12;
 500         private const int ULOC_SCRIPT_CAPACITY = 6;
 501         private const int ULOC_COUNTRY_CAPACITY = 4;
 502         private const int ULOC_VARIANT_CAPACITY = ULOC_FULLNAME_CAPACITY;
 503
 504         internal ULocale(string locale)
 505         {
 506             Locale = Canonicalize(locale);
 507             Language = GetLanguage(Locale);
 508             Script = GetScript(Locale);
 509             Country = GetCountry(Locale);
 510             Variant = GetVariant(Locale);
 511             LCID = GetLCID(Locale);
 512         }
 513
 514         internal string Locale { get; private set; }
 515         internal string Language { get; private set; }
 516         internal string Script { get; private set; }
 517         internal string Country { get; private set; }
 518         internal string Variant { get; private set; }
 519         internal int LCID { get; private set; }
 520
 521         private string Canonicalize(string localeName)
 522         {
 523             // Get the locale name from ICU
 524             StringBuilder sb = new StringBuilder(ULOC_FULLNAME_CAPACITY);
 525             if (Interop.BaseUtilsi18n.Canonicalize(localeName, sb, sb.Capacity) <= 0)
 526             {
 527                 return null;
 528             }
 529
 530             return sb.ToString();
 531         }
 532
 533         private string GetLanguage(string locale)
 534         {
 535             // Get the language name from ICU
 536             StringBuilder sb = new StringBuilder(ULOC_LANG_CAPACITY);
 537             if (Interop.BaseUtilsi18n.GetLanguage(locale, sb, sb.Capacity, out int bufSizeLanguage) != 0)
 538             {
 539                 return null;
 540             }
 541
 542             return sb.ToString();
 543         }
 544
 545         private string GetScript(string locale)
 546         {
 547             // Get the script name from ICU
 548             StringBuilder sb = new StringBuilder(ULOC_SCRIPT_CAPACITY);
 549             if (Interop.BaseUtilsi18n.GetScript(locale, sb, sb.Capacity) <= 0)
 550             {
 551                 return null;
 552             }
 553
 554             return sb.ToString();
 555         }
 556
 557         private string GetCountry(string locale)
 558         {
 559             int err = 0;
 560
 561             // Get the country name from ICU
 562             StringBuilder sb = new StringBuilder(ULOC_COUNTRY_CAPACITY);
 563             if (Interop.BaseUtilsi18n.GetCountry(locale, sb, sb.Capacity, out err) <= 0)
 564             {
 565                 return null;
 566             }
 567
 568             return sb.ToString();
 569         }
 570
 571         private string GetVariant(string locale)
 572         {
 573             // Get the variant name from ICU
 574             StringBuilder sb = new StringBuilder(ULOC_VARIANT_CAPACITY);
 575             if (Interop.BaseUtilsi18n.GetVariant(locale, sb, sb.Capacity) <= 0)
 576             {
 577                 return null;
 578             }
 579
 580             return sb.ToString();
 581         }
 582
 583         private int GetLCID(string locale)
 584         {
 585             // Get the LCID from ICU
 586             uint lcid = Interop.BaseUtilsi18n.GetLCID(locale);
 587             return (int)lcid;
 588         }
 589
 590         internal static string GetDefaultLocale()
 591         {
 592             IntPtr stringPtr = IntPtr.Zero;
 593             if (Interop.BaseUtilsi18n.GetDefault(out stringPtr) != 0)
 594             {
 595                 return string.Empty;
 596             }
 597
 598             if (stringPtr == IntPtr.Zero)
 599             {
 600                 return string.Empty;
 601             }
 602
 603             return Marshal.PtrToStringAnsi(stringPtr);
 604         }
 605     }
 606 }