It was a vague AV, giving me just a few NT OS functions in call stack trace, and stopping on any line containing Result (as the return value for a property getter). I reviewed the code several times, everything seemed OK, and I had only changed tens of lines of code, so I was really confused where the hell this AV came from; I mean, I knew which property getter method was causing the error, and the method was not lengthy or complicated, but I had no clue how come it was causing such an AV >-(

Eventually while I was reviewing the changed codes again and again, I noticed something; there was a Windows API call which required a PBOOL parameter, and I had called it twice in the function code. One call was written a while ago, and the other was written tonight. The problem was, for the second call I had defined the parameter as Boolean rather than defining it as BOOL (passing its address using @ operator). That’s a shame!

So here’s a personal note for myself: Do not code at 2 AM, specially when you are kinda sleepy. If you did, make sure your eyes can distinguish between BOOL, and Boolean

As I checked the bugs list, at least one bug regarding BiDi support (QC # 97965) is fixed in VCL Styles. No other BiDi related bugs are fixed in this update. Embarcadero staff mentioned in Embarcadero newsgroups that the company is planning to release monthly updates for XE2 product, so we should wait to see if any of the BiDi related bugs will be fixed in the coming updates or not.

The easiest way to enumerate Windows services is using WMI. Of course using WMI requires some basic knowledge of MS COM technology which is tricky, but thanks to the great tool. Delphi WMI Class Generator by Rodrigo Ruz, you can have a ready Delphi class for obtaining information about installed services on a Windows machine without even writing a single line of code. All you have to know is that WMI class for Windows services is Win32_Service under root\CIMV2 namespace. Delphi WMI Class Generator will generate a unit named uWin32_Service.pas which contains a class named TWin32_Service. This class returns info about a single service for you. If you need to enumerate all installed services, you need to write a couple of codes to call its GetCollectionCount to retrieve number of available services, and SetCollectionIndex to set current item index for the class. Here is a sample code to retrieve names of all installed services on the local machine using TWin32_Service class:

var
  i: Integer;
begin
  with TWin32_Service.Create do
  try
    for i := 0 to GetCollectionCount - 1 do
    begin
      Writeln(DisplayName);
      SetCollectionIndex(i);
    end;
  finally
    Free;
  end;
end;

However, WMI is slow, and it relays on WMI service. If you need a faster way to enumerate Windows services, or if for whatever reason WMI service is disabled or not working on your target machine; then you have to relay on Windows API. Using Windows API for this purpose is not as easy as using the automatically generated TWin32_Service class. I am not aware of a single Windows API function that can enumerate Windows services for you and give you all the detailed information which WMI returns for each service. You have to call roughly a dozen of API functions to enumerate Windows services and retrieve some nice information for each service.

First you need to open a handle to service manager on the target machine by calling OpenSCManager function, then you should call EnumServicesStatusEx function to enumerate available services, and retrieve their names and status. If you just need service names and status, you are done, but if you need to retrieve description and configuration for each service too, then you should open a handle for each service using OpenService function by giving it service name which you obtain through EnumServicesStatusEx call , and then call QueryServiceConfig and QueryServiceConfig2 functions to get the required configurations. At the end you should make sure you free all the allocated buffers, and close all handles. Delphi installation does not provide header translation for some of these API functions (particularly EnumServicesStatusEx and QueryServiceConfig2), but they are translated and available for Delphi by well-known Project JEDI, and their JEDI Windows API Headers which contain the majority of Windows headers. If you are a Delphi developer and have not heard about them yet (That would be weird!!), you can download the package from this link.

Anyways, in the source code below, I wrapped all of those API calls into a class named TAkServices. This class holds an internal list containing information for each Windows service installed on a given machine. I tested it on both Delphi 2010 (Win32) and Delphi XE2 (Win64):

{*******************************************************************************
/// <author> Ali Keshavarz (vcldeveloper@gmail.com) </author>
/// <date> 09/13/2011 </date>
/// <license>
///  This work is licensed under the Creative Commons Attribution 3.0 Unported
///  License. To view a copy of this license, visit
///  http://creativecommons.org/licenses/by/3.0/
///  or send a letter to Creative Commons, 171 Second Street, Suite 300,
///  San Francisco, California, 94105, USA.
/// </license>
*******************************************************************************}

unit uAkServices;

interface

uses
 Generics.Collections;

type
 /// Service status values; these items are defined in Windows SDK. For more
 /// info refer to MSDN.
 TAkServiceState = (SERVICE_STOPPED          = $۰۰۰۰۰۰۰۱,
 SERVICE_START_PENDING    = $۰۰۰۰۰۰۰۲,
 SERVICE_STOP_PENDING     = $۰۰۰۰۰۰۰۳,
 SERVICE_RUNNING          = $۰۰۰۰۰۰۰۴,
 SERVICE_CONTINUE_PENDING = $00000005,
 SERVICE_PAUSE_PENDING    = $۰۰۰۰۰۰۰۶,
 SERVICE_PAUSED           = $۰۰۰۰۰۰۰۷ );

 /// Service startup mode values; these items are defined in Windows SDK. For
 /// more info refer to MSDN.
 TAkServiceStartMode = (SERVICE_BOOT_START,
 SERVICE_SYSTEM_START,
 SERVICE_AUTO_START,
 SERVICE_DEMAND_START,
 SERVICE_DISABLED );

 /// <summary>
 /// Service information structure. This structure is used by TAkServiceList
 /// class to save info for each individual service.
 /// </summary>
 TAkServiceInfo = record
 public
 /// A path to service executable file.
 BinaryPath : string;
 /// Current service state.
 CurrentState : TAkServiceState;

 Description : string;
 /// User-friendly name of service
 DisplayName : string;
 /// Service flags. It can be either zero or SERVICE_RUNS_IN_SYSTEM_PROCESS.
 Flags : Integer;
 /// Actual name of service which is also used as service key name in Registry.
 Name : string;
 /// Process identifier for a running service. If the service is not running
 /// or it is running in System process, then ProcessID will be zero.
 ProcessID : Cardinal;
 /// Startup mode of service.
 StartMode : TAkServiceStartMode;
 /// Username by which service logged into system.
 StartName : string;
 end;

 /// Holds a list of TAkServiceInfo reccords as the list of Windows services.
 TAkServiceList = TList<TAkServiceInfo>;

 TAkServiceInfoEnumerator = TEnumerator<TAkServiceInfo>;

 /// <summary>
 /// Provides a list of installed Windows services on a given machine.
 /// </summary>
 TAkServices = class
 private
 FLastUpdateTime : TDateTime;
 FList : TAkServiceList;
 FMachineName : string;
 function GetCount: Integer;
 function GetItem(Index: Integer): TAkServiceInfo;
 procedure GetServiceConfig(hSCManager: Cardinal; var Service: TAkServiceInfo);
 procedure SetMachineName(const Value: string);
 protected
 procedure InitializeList; virtual;
 procedure InternalRefresh; virtual;
 public
 /// <summary>
 /// Constructor for TAkServices.
 /// </summary>
 /// <param name="AMachineName">
 ///  (in) Name of the machine which its services should be listed. Default = ''
 /// </param>
 /// <param name="."></param>
 constructor Create(const AMachineName: string = '');
 destructor Destroy; override;
 function GetEnumerator: TAkServiceInfoEnumerator;
 /// <summary> Updates list of services. </summary>
 procedure Refresh;
 /// <summary>
 /// Indicates number of services. If the list is not updated yet, it will be
 /// updated first.
 /// </summary>
 property Count: Integer read GetCount;
 /// <summary>
 /// Returns item at the Index position of the list of services.
 /// If the list is not updated yet, it will be updated first.
 /// </summary>
 property Item[Index: Integer]: TAkServiceInfo read GetItem; default;
 /// <summary>
 /// Indicates last update time for the list. It will be updated each time
 /// Refresh method is called.
 /// </summary>
 property LastUpdateTime: TDateTime read FLastUpdateTime;
 /// <summary>Name of the machine which its services should be listed. </summary>
 property MachineName: string read FMachineName write SetMachineName;
 end;

implementation

uses
 SysUtils,
 Windows,
 JwaWinNT,
 JwaWinType,
 JwaWinSvc,
 JwaWinError;

{ TAkServices }

constructor TAkServices.Create(const AMachineName: string);
begin
 inherited Create;
 FMachineName := AMachineName;
end;

destructor TAkServices.Destroy;
begin
 System.TMonitor.Enter(Self);
 try
 FList.Free;
 FList := nil;
 finally
 System.TMonitor.Exit(Self);
 end;

 inherited;
end;

function TAkServices.GetCount: Integer;
begin
 InitializeList;
 Result := FList.Count;
end;

function TAkServices.GetEnumerator: TAkServiceInfoEnumerator;
begin
 InitializeList;
 Result := FList.GetEnumerator;
end;

function TAkServices.GetItem(Index: Integer): TAkServiceInfo;
begin
 InitializeList;
 Result := FList[Index];
end;

procedure TAkServices.InitializeList;
begin
 if not Assigned(FList) then
 begin
 System.TMonitor.Enter(Self);
 try
 FList := TAkServiceList.Create;
 InternalRefresh;
 finally
 System.TMonitor.Exit(Self);
 end;
 end;
end;

procedure TAkServices.GetServiceConfig(hSCManager: Cardinal; var Service: TAkServiceInfo);
var
 dwBufNeeded: Cardinal;
 dwBufSize: Cardinal;
 hService : Cardinal;

 /// <summary>
 /// Retrieves service binary path, start mode, and user name.
 /// </summary>
 procedure GetRequiredConfig(var Service: TAkServiceInfo);
 var
 lpServiceConfig : LPQUERY_SERVICE_CONFIG;
 begin
 dwBufSize := 0;
 dwBufNeeded := 0;
 /// Retrieve required buffer size.
 QueryServiceConfig(hService, nil, dwBufSize, dwBufNeeded);
 if GetLastError <> ERROR_INSUFFICIENT_BUFFER then
 RaiseLastOSError;

 /// Alocate enough buffer size.
 dwBufSize := dwBufNeeded;
 lpServiceConfig := AllocMem(dwBufSize);
 try
 /// Get service configuration
 if not QueryServiceConfig(hService, lpServiceConfig, dwBufSize, dwBufNeeded) then
 RaiseLastOSError;

 /// Save configuration data in the record.
 Service.BinaryPath := lpServiceConfig.lpBinaryPathName;
 Service.StartMode := TAkServiceStartMode(lpServiceConfig.dwStartType);
 Service.StartName := lpServiceConfig.lpServiceStartName;
 finally
 FreeMem(lpServiceConfig);
 end;
 end;

 /// <summary>
 /// Retrieves service description.
 /// </summary>
 procedure GetOptionalConfig(var Service: TAkServiceInfo);
 var
 lpServiceDescBuff : LPSERVICE_DESCRIPTION;
 begin
 dwBufSize := 0;
 dwBufNeeded := 0;
 /// Retrieve required buffer size.
 QueryServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, nil, dwBufSize, dwBufNeeded);
 if GetLastError <> ERROR_INSUFFICIENT_BUFFER then
 RaiseLastOSError;

 /// Alocate enough buffer size.
 dwBufSize := dwBufNeeded;
 lpServiceDescBuff := AllocMem(dwBufSize);
 try
 /// Retrieve service description
 if not QueryServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION,
                            PByte(lpServiceDescBuff), dwBufSize, dwBufNeeded) then
   RaiseLastOSError;
  /// Save service description in the record.
  if Assigned(lpServiceDescBuff.lpDescription) then
   SetString(Service.Description,
             lpServiceDescBuff.lpDescription,
             StrLen(lpServiceDescBuff.lpDescription));
   finally
     FreeMem(lpServiceDescBuff);
   end;
 end;

begin
  Assert(hSCManager > 0, 'Service manager is not initialized.');

  /// Open a service handle to be used by QueryServiceConfig() and QueryServiceConfig2() functions.
  hService := OpenService(hSCManager,PChar(Service.Name),SERVICE_QUERY_CONFIG);
  if hService = 0 then
    RaiseLastOSError;
  try
    GetRequiredConfig(Service);
    GetOptionalConfig(Service);
  finally
    CloseServiceHandle(hService);
  end;
end;

procedure TAkServices.InternalRefresh;
var
  dwBufNeeded: Cardinal;
  dwBufSize: Cardinal;
  dwNumOfServices: ULONG;
  hSCM: SC_HANDLE;
  lpResumeHandle: Cardinal;
  NewItem : TAkServiceInfo;
  pBuf: PBYTE;
  pInfo: LPENUM_SERVICE_STATUS_PROCESS;
  i: Integer;
begin
  Assert(Assigned(FList),'Internal list is not assigned yet!');

  System.TMonitor.Enter(FList);
  try
   dwBufSize := 0;
   dwBufNeeded := 0;
   dwNumOfServices := 0;
   lpResumeHandle := 0;
   FList.Clear;

   /// We need an open service manager handle to be able to enumerate services.
   hSCM := OpenSCManager(PChar(FMachineName), nil,
   SC_MANAGER_ENUMERATE_SERVICE or SC_MANAGER_CONNECT);
   if (hSCM = 0) then
     RaiseLastOSError;

   try
     /// First check how much buffer is needed by passing dwBufSize as zero,
     /// and pBuf as nil.
     EnumServicesStatusEx(hSCM, SC_ENUM_PROCESS_INFO, SERVICE_WIN32,
                          SERVICE_STATE_ALL, nil, dwBufSize, dwBufNeeded,
                          dwNumOfServices, lpResumeHandle, nil);
     if (dwBufNeeded < 1) then
       RaiseLastOSError;

     /// Alocate enough space for the buffer.
     dwBufSize := dwBufNeeded;
     pBuf := AllocMem(dwBufSize);
     try
       /// Retrieve services list
       if not EnumServicesStatusEx(hSCM, SC_ENUM_PROCESS_INFO, SERVICE_WIN32,
                                   SERVICE_STATE_ALL, pBuf, dwBufSize, dwBufNeeded,
                                   dwNumOfServices, lpResumeHandle, nil) then
         RaiseLastOSError;

       /// Type casting pBuf to LPENUM_SERVICE_STATUS_PROCESS record is necessary
       ///  so that we can access each service info in the buffer as a record.
       pInfo := LPENUM_SERVICE_STATUS_PROCESS(pBuf);
       /// Write services list
       for i := 0 to dwNumOfServices-1 do
       begin
         NewItem.Name := pInfo.lpServiceName;
         NewItem.DisplayName := pInfo.lpDisplayName;
         NewItem.Flags := pInfo.ServiceStatusProcess.dwServiceFlags;
         NewItem.ProcessID := pInfo.ServiceStatusProcess.dwProcessId;
         NewItem.CurrentState := TAkServiceState(pInfo.ServiceStatusProcess.dwCurrentState);
         GetServiceConfig(hSCM, NewItem);
         FList.Add(NewItem);

         /// Go to next record in the buffer. Compiler will increment pInfo pointer
         ///  according to size LPENUM_SERVICE_STATUS_PROCESS record.
         Inc(pInfo);
       end;
       FLastUpdateTime := Now;
    finally
       FreeMem(pBuf);
    end;
  finally
    CloseServiceHandle(hSCM);
  end;
  finally
     System.TMonitor.Exit(FList);
  end;
end;

procedure TAkServices.Refresh;
begin
 /// If FList is not created yet, InitializeList will create it and calls InternalRefresh
 /// automatically, but if the list is already created, just calling InternalRefresh
 /// is enough.
 if not Assigned(FList) then
 InitializeList
 else
 InternalRefresh;
end;

procedure TAkServices.SetMachineName(const Value: string);
begin
 if not SameText(FMachineName, Value) then
 begin
    FMachineName := Value;
    Refresh;
  end;
end;

end.

Here is also a demo Delphi application using TAkServices class to enumerate Windows services on the local machine, and show them in a ListView control. Download link for the source files (including uAkServices.pas and all required JEDI API header translations) is available at the end of this article:

Demo application in action; enumerating Windows services using Windows API

Download:

Source code plus the demo app

P.S. Oops, it seems my code highlighter is not keen on indentation in longer source codes. If you see the code without proper indentation, you can use this pastebin link to see the source formatted properly, or download the source file. I’m sorry for the inconvenience.

• Added support for Win64 and Delphi XE2.
• Added TProcessItem.CloseProcess method to close a process normally (not forcefully).
• Added TProcessItem.CurrentProcess property. This property always refers to the current process in the list of running processes.
• Added PrivateWorkingSetSize property to TProcessItem.MemoryInfo.
• Added global  ProcessInformation function. This function returns a global instance of TProcessInfo. The instance will be freed when the application is terminating.
• Fixed a few minor bugs.

To download ProcessInfo 1.5, please go to ProcessInfo page.

First of all I should mention that I didn’t expect any BiDi support in this version, so my initial intention was to highlight the bugs for BiDi support in FireMonkey and report them to be hopefully fixed in the future releases. The first impression was that FireMonkey is not as bad as VGScene in supporting BiDi text. It was a surprise because I didn’t really expect any BiDi support after reading Andreano’s comment. There is very limited and half baked support for BiDi text in the initial release and it still has a long way to go for fully supporting BiDi text. Here I am going to discuss support for BiDi text in FireMonkey version 1.0, highlighting the bugs which should be fixed regarding this support, and the QC report regarding each bug.

Before I discuss BiDi support, I should mention that according to Michael Swindell, Senior vice president of marketing and product management at Embarcadero, FireMonkey will be updated frequently. The first update is expected before the end of September, and the other updates will be published more often than quarterly [Source]. That means, we will see several updates for FireMonkey before the new version of RAD Studio is published next year. That is really exciting and makes me very hopeful that all or at least many of the bugs mentioned here might be fixed before the next major release of RAD Studio in 2012. It is important to be hopeful about evolution of a product, and feel that your feedbacks are really considered by its developers. Years ago many of my friends tried to notify Borland about some of the existing bugs in VCL regarding BiDi and right-to-left languages support, but they never got fixed, and many of those guys migrated to .NET, abandoning Delphi. I myself stopped reporting any new bug to QC when Embarcadero deleted my EDN account just because my country in my profile was mentioned as Iran. Now I feel the team listens more to user feedbacks. It doesn’t really matter if I am Iranian or American or whatever when I am reporting a bug or when I am discussing some technical stuff. Anyways, that is another story and I discussed that in an older blog post. Let’s go back to FireMonkey and its support for BiDi text:

The first thing that I noticed in FireMonkey regarding BiDi support was a new BiDiMode property added to FireMonkey forms. This property determines if the whole form is right-to-left or left-to-right. When it is set to bdRightToLeft, it changes TextAlign property of the child controls inside the form, and set the text inside them aligned right to left. It also enables BiDi reading in the text for many of the controls so that a text containing a mixture of Latin and a right-to-left language (e.g. Arabic, Persian, Hebrew) characters is read correctly. If you remember from the older post on this subject, VGScene lacked such a feature. Having this effect makes FireMonkey a little more useful in right-to-left applications. At least in many cases your users will be able to read the text shown to them properly.

However the idea of having a single BiDiMode property to govern all the child controls inside a form is not practically appealing, because it is very common for a right-to-left from to contain Latin or numeric elements which should be laid out left-to-right rather than  right-to-left. Actually all FireMonkey controls should have a BiDiMode property governing the layout of that particular control and its children; something similar to BiDiMode property in VCL controls.

Another problem that is visible when BiDiMode of a form is set to bdRightToLeft is in the form title; the title is not BiDi-aware so if it contains a mixture of Latin and right-to-left characters, it will show the text incorrectly. Also layout of the title is not right; in a right-to-left window the default coordinates system starts from the upper right corner, form icon is on the right side of the title bar, form title is next to it, and window buttons (min, max, close) are on the left side of the form, that means mirroring the position of title bar elements. Right now the title bar for right-to-left forms are aligned the same way as left-to-right forms which is wrong:

BUG: FireMonkey form title does not change when BiDiMode is bdRightToLeft

VCL forms have the same problem. It gets even more irritating when you use a right-to-left VCL form with Ribbon controls; Ribbon application button overlaps with Close button, making it very hard for the user to click on Close button.

Now let’s see how child controls react when BiDiMode is set to bdRightToLeft. First of all, I checked TEdit control. It is the common control for receiving text input. There are two type of textual edit controls in FireMonkey; TEdit, and TClearingEdit. The latter has a button at the end of the control which clears the text inside the control, when clicked:

Right-to-left edit boxes in FireMonkey have a couple of minor visual bugs.

As you can see in the picture above, BiDi text is shown correctly in those edit controls, but they have two other bugs; first of all, when an edit control receives focus, the cursor remains on the left side of the edit box, blinking. The cursor should be at the right corner of the edit box when the control is set right-to-left. Even when an edit box is focused and input language is changed, if the input language is right-to-left, the cursor should jump to the right side of the box.  This false behavior is not exclusive to TEdit, actually all controls that receive text input (e.g. CombBoxes, Memos, etc.) have the same problem with their cursor position. The other problem is with TClearingEdit control; clear button inside the control should be positioned on the left side when text is right-to-left, and on the right side when text is left-to-right.

ComboBoxes have an additional bug beside the other one I mentioned for edits; the items in the drop down list are left-aligned and not BiDi-aware (i.e. mixing Latin and right-to-left characters destroys proper text reading):

BUG: Items are left-aligned and item texts are not BiDi-aware.

Unfortunately right-to-left Memo is useless in FireMonkey. This memo control is really buggy, even when it is not right-to-left. Anyways, as you can see in the picture below, a right-to-left memo does not show the text at all. The text is there as the cursor is blinking where the text is ended, but no text is visible:

BUG: Right-to-left text disappears in FireMonkey Memo control.

TreeView in FireMonkey acts similar to TreeView in VGScene, the items are right-aligned, but the arrow icon indicating each node sub-items, and the indentation for each sub-item are drawn on the left-side, making the right-to-left TreeView looking weird. The only improvement here is in BiDi text reading; as you can see in the picture, BiDi text is read correctly when Latin and right-to-left characters are mixed together:

BUG: Arrow icon and indentations for the sub-items remain on the left side.

As I mentioned in the first part of this investigation, it is been so many years that TreeView in VCL has problem with right-to-left too. I hope we see it fixed someday soon too.

TabControl in FireMonkey isn’t any better than PageControl in VCL; they both ignore right-to-left setting, and remain left-aligned:

BUG: Tabs are shown left-to-right rather than right-to-left

Now the menus; both FireMonkey and VCL have problem in showing right-to-left menus properly. They both draw the menu (either main menu or popup menu) left-aligned, so that the icon is shown on the left side of each menu item rather than the right side. FireMonkey has two additional bugs in its menu; first of all, BiDi text reading in the menu is not implemented, so mixing Latin and right-to-left characters in a text makes the text unreadable. Beside that, menu items in the main menu are always started from left to right:

BUG: Menus have no BiDi support and is left-aligned.

The last control I investigated was TStringGrid; TDBGrid in VCL was one of the rare controls which had nice right-to-left support, but such a nice support does not exist in FireMonkey; TStringGrid in FireMonkey can be attached to a dataset thanks to the new Live Binding feature, but columns are always drown left-to-right. What’s more, having separate BiDiMode property for each column is more important here, because each column might have right-to-left, Latin, or numerical data, and we cannot expect all such data to be aligned either left-to-right or right-to-left:

BUG: Grid columns are always laid out left-to-right

Conclusion

With all these bugs in right-to-left support, is FireMonkey 1.0 really usable for right-to-left applications? The short answer is, No. The longer answer is; there is some basic support for reading BiDi text, so at least you can have some single-lined text in your application. With this basic support you can create some limited demo applications or some trivial fun stuff, but not really any serious business application. However, as I mentioned earlier, the good news is that FireMonkey is supposed to be updated frequently, so we can be hopeful that many of these bugs might be fixed in the coming months.

In this article I mentioned many VCL bugs regarding right-to-left support too, I hope Embarcadero consider these old VCL bugs too, and fix them eventually.

Anyways, here is a list of QC reports regarding the bugs I mentioned in this article. If you need proper right-to-left support in your Delphi or C++ Builder applications, please take a few minutes, and vote for these reports in Quality Central, so that Embarcadero would deal with them more seriously:

• QC #98647: BiDi support in FireMonkey is broken.
• QC #97604: Cursor position always left with BidiMode = bdRightToLeft.
• QC #98644: All FireMonkey controls should have BiDiMode property.
• QC #98638: TMemo does not render BiDi text.
• QC #98770: Clear button is positioned incorrectly when BiDiMode is set to bdRightToLeft.
• QC #98771: ComboBox has no proper BiDi support.
• QC #98772: TreeView is not properly right aligned when BiDiMode is set to bdRightToLeft.
• QC #98773: TTabControl is not right aligned when BidiMode is set to bdRightToLeft.
• QC #98774: Both main menu and popup menu have serious problems in supporting bi-directional text.
• QC #98775: TStringGrid has no proper support for bi-directional text.

BTW, here is a request in Delphi UserVoice website demanding better support for bidirectional user interfaces in Delphi. Please vote for this one too:

• Better support for Bidirectional user interfaces

And here  is download link for the 30-days trial version from Embarcadero. Before installing the final version, if you already have XE2 beta installed, make sure you uninstall it completely and remove all of its folders which might remain undeleted; otherwise, you might have to deal with weird installation issues.

I hope this will be a new start for Delphi

Before I describe my experience with VGScene, let me explain what supporting bi-directional text really means, why is it important, and what kind of support for it exists in MS Windows…

What is support for BiDi , and why is it important?

First of all, you probably know that, not all languages in the world are written from left to right; a few languages including Arabic, Persian, Urdu, Hebrew, and Maldivian are written from right to left. Some languages like Chinese can be written in any direction; left to right, right to left, or top to down.

Displaying a right-to-left text in computers is not as simple as flipping the screen order, because in some cases, your right-to-left text may contain left-to-right character too. That way, either the left-to-right or the right-to-left characters would be displayed incorrectly. Such a text which is a mixture of left-to-right and right-to-left characters is called Bi-directional (BiDi) text, and supporting bi-directional text in computer means displaying and inputting BiDi text correctly. You can read more about it in Wikipedia.

But why is BiDi important?

Right-to-left languages are widespread in Middle East, North Africa, and Central Asia. Arabic has the third largest population of official usages in the world, after English and French, with 26 countries using it as their official language, and more than 280 million people speaking it as their first language. It is also language of Quran (Koran), the holly Muslims’ book. Quran and Islamic prayers are read in Arabic, so every Muslim in the world should have a basic knowledge of Arabic to say his/her daily prayers. Islam is the second largest religion in the world with more than 1.5 billion followers all over the world, and the one with the fastest pace of growth.

Persian is the official language in 3 countries with more than 100 million population. Urdu is the official language in Pakistan, with more than 60 million speakers. Hebrew is the Jewish language, and language of Torah. There are more than 13 million Jews around the world.

Summing all of these, more than 400 million people in 30 countries all over the world are using a right-to-left language as their first language, and more than 1.5 billion people are using a right-to-left language as their religious language.

From software development point of view, if you are writing a software targeting any market in Middle East, Central Asia, or North Africa, or writing a religious software for Muslims or Jews; you need BiDi support in your software.

BiDi support in Windows

Win32 always have had adequate support for right-to-left languages. Currently Windows supports Arabic and Hebrew scripts. Persian uses Arabic alphabet, so supporting Arabic is enough to support Persian too. Since Windows 2000, Windows started to fully support Unicode, which made supporting displaying and inputting right-to-left text in Windows easier. Win32 also supports right-to-left layout for controls and windows using some extended styles. Particularly, Win32 provides four extended styles regarding BiDi support in Windows controls:

• WS_EX_LAYOUTRTL
  Arabic and Hebrew versions of Windows 98/Me, Windows 2000/XP: Creates a window whose horizontal origin is on the right edge. Increasing horizontal values advance to the left.
• WS_EX_LEFTSCROLLBAR
  If the shell language is Hebrew, Arabic, or another language that supports reading order alignment, the vertical scroll bar (if present) is to the left of the client area. For other languages, the style is ignored.
• WS_EX_RIGHT
  The window has generic “right-aligned” properties. This depends on the window class. This style has an effect only if the shell language is Hebrew, Arabic, or another language that supports reading-order alignment; otherwise, the style is ignored. Using the WS_EX_RIGHT style for static or edit controls has the same effect as using the SS_RIGHT or ES_RIGHT style, respectively. Using this style with button controls has the same effect as using BS_RIGHT and BS_RIGHTBUTTON styles.
• WS_EX_RTLREADING
  If the shell language is Hebrew, Arabic, or another language that supports reading-order alignment, the window text is displayed using right-to-left reading-order properties. For other languages, the style is ignored.

Using these styles, you can have right-to-left windows and child controls with proper BiDi text displaying and input. Microsoft provided the same support for BiDi in .NET WinForms, and WPF windows too.

BiDi support in Delphi VCL

In Delphi, BiDi support is basically provided in TControl class by exposing BiDiMode property which specifies four different modes of displaying and layouting controls for left-to-right or right-to-left text. Beside that, TWinControl class provides FlipChildren method which flips children of a container control from left to right or vice versa. Also TApplication class has two properties; BiDiKeyboard, and NonBiDiKeyboard which specify keyboard layout which should be loaded automatically based on a BiDiMode value of a control when user focuses on that particular control. For example, you can specify Arabic layout code for Application.BiDiKeyboard, and English layout code for Application.NonBiDiKeyboard in your source code, and whenever the user focuses on a right-to-left control in any of application forms, the active input keyboard changes to Arabic, and when he/she focuses a left-to-right control, the active input keyboard changes to English. Take note that Application.NonBiDiKeyboard and Application.BiDiKeyboard are kinda useless in Windows Vista and Windows 7, because they call LoadKeyboardLayout API function every time a control is focused, instead of ActiveKeyboardLayout API, and in such versions of Windows that causes a big delay which makes the forms load slower, and flicker when focus is changed; but that is another story.

There are some other methods and functions in VCL that can help you to write a BiDi-enabled application. You can read more about BiDi support in VCL in RAD Studio documentation.

As you can see, BiDi support is built into VCL deep from its base class for all controls. The problem is that, not all controls in VCL hierarchy implement this feature properly; that means, there are many different controls that while being created or being drawn, do not take BiDi support into consideration, so changing their BiDiMode property have no effect on them, or in some cases brings up unexpected behaviors. For example, attaching a right-to-left DBGrid to ClientDataset will draw the grid totally useless:

Left-to-right DBGrid with BiDi text.

Right-to-Left DBGrid attached to ClientDataset

Setting BiDiMode for Delphi Ribbon, or PageControl, or TreeView control has no effect on them. PageControl and TreeView are standard Windows controls with support of right-to-left layout, but they are not wrapped properly in VCL:

VCL: BiDiMode is set to bdRightToLeft, but PageControl is still left-tot-right.	WinForms: TabControl is properly set to right-to-left alignment.
VCL: BiDiMode is set to bdRightToLeft, but TreeView, and CategoryButtons are still left-tot-right.	WinForms: TreeView is properly set to right-to-left alignment.

Sometimes setting BiDiMode for a control to bdRightToLeft makes its text BiDi-enabled, but the control itself is not layouted right-to-left:

BiDiMode is set to bdRightToLeft, but main menu control is aligned left-to-right.

WinForms: Menu is properly set to right-to-left alignment.

BiDi support in third-party components is not consistent either; some components like FastReport have very nice support for BiDi text. Raize components are usually good in right-to-left layout thanks to their custom rendering methods. VirtualTreeView and EhLib have nice BiDi support too. I like TMS components a lot, specially their Smooth Controls, but BiDi support in TMS components is weak, except their grid component. I don’t use DevExpress components, but I heard their components are quiet good in handling BiDi.

BiDi support in KSDev VGScene

OK, examining this one was the main reason of writing this blog post; the truth is, unfortunately, VGScene has no BiDi support, yes you read it right, NO support. I checked properties in VGScene controls several times; no such BiDiMode, or RightToLeft, or RTL property exists. VGScene is not able to render BiDi text properly, or set proper right-to-left alignment for its controls.

There is a property called TextAlign in some controls, at first I thought that is the property I was looking for, but later on I found out it just aligns text in the control to either left or right side, but does not set text direction accordingly, that means no BiDi support!

If you don’t know Persian, you might think text in the pictures below is drawn correctly; however, if you look carefully, you will notice the dot (.) character at the beginning of the right-to-left text in VGScene screenshot. You may also notice that text shown in VGScene is not the same as the text in WPF.Actually the text in WPF screenshot means “This is a Test”, and Test is written in English while the rest of it is written in Persian. The text in VGScene screenshot is meaningless; that is because VGScene has no sense of BiDi, and when you mix a Latin character or punctuation symbol with your right-to-left characters, it draws the whole text as a mess.

VGScene

WPF

Well VGScene is not able to properly change layout of a control to right-to-left either. The screenshot below shows two TreeView controls in VGScene, in the left control TextAlign is set to left, and in the right control it is set to right. As you can see, when you right-align a treeview item, its text goes to the right side, but the arrow icon and children indentation remain on the left-side, making the TreeView to look something like a simple ListBox:

Even if TextAlign property was supposed to be a property to define BiDi mode, Unlike BiDiMode in VCL or RightToLeft in WinForms or FlowDirection in WPF, it does not affect other controls hierarchically; that means, you should set it for every control separately, even in TreeView case, for every tree node.

For VGScene to support BiDi mode properly, it needs to add a property similar to BiDiMode in VCL in the base control class, and it should change the code for drawing a control or its text according to the value of this new property. How WPF implemented support for BiDi mode in the user interface can be a good template for modifying VGScene (or FireMonkey) to properly support BiDi text. You can read more about BiDi support in WPF here: Bidirectional features in WPF overview.

Conclusion

It is obvious that BiDi support was not a goal in VGScene design. VGScene is not in development anymore. It is sold to Embarcadero, and now its sequel is called FireMonkey. As I mentioned earlier, it is not clear whether FireMonkey will bring proper support for BiDi text or not. I am personally doubtful about it; because some of the new VCL controls are designed with no BiDi support in mind, and many obvious BiDi-related bugs in the older controls are remained unfixed for years. To me that is an indication that such a support is not a big concern for Embarcadero developers. What’s more, Andreano Lanusse somehow ignored answering my question regarding this support in FireMonkey, which can be another indication that such a support does not exist. I really hope my doubt is proved wrong, because if BiDi support in FireMonkey is the same as what I saw in VGScene, this tool will be useless in BiDi environments.

Update (08/24/2011)

As you can read in the comment; Andreano Lanusse from Embarcadero confirmed that FireMonkey in RAD Studio XE2 will not have BiDi support, but they included it in their RoadMap. The roadmap is not  published yet, thus we gotta wait for it and see when is BiDi support supposed to be included in FireMonkey. I hope they do it in an update pack for XE2 rather than postponing it to future releases of RAD Studio. Here I also should appreciate Andreano’s efforts for informing me and trying to include this feature in their roadmap.

It was obvious that XE2 will bring 64-bits support to Delphi, along with supporting Mac OS as a new target platform. Mac OS support was supposed to be added to Delphi XE, but it was postponed to this release. Although 64-bits and Mac OS support are cool, they were both expected. The big news was FireMonkey!

When Embarcadero announced their plan for adding Mac OS support, the original plan was a continuation of the old CLX framework which was based on Qt. The difference was, the new CLX was supposed to bring just cross-compiling for Mac OS (and later on Linux), not like original CLX which had a Linux-based IDE (Kylix) for compiling the same source code for Linux. However the plan changed, Embarcadero bought KSDev company, creator of VGScene and DXScene components, and hired its programmer. They decided to provide a vector-based, GPU accelerated, cross-platform GUI framework based on the recently bought KSDev products; and that is FireMonkey.

FireMonkey is the new cross-platform GUI framework for Delphi. You can create Windows (32-bits, 64-bits), Mac OS (32-bits), and iOS (32-bits) applications using FireMonkey in Delphi XE2. iOS addition was a surprised, and I didn’t expect it; although it is not a direct compilation to ARM code. Actually you have to export your iOS code to a XCode project, and compile it with XCode, to be able to run it on your iPhone or iPad devices. Also, 64-bits support for Mac is not ready yet. It seems they are still working on it.

On Windows platform, FireMonkey uses Direct2D for 2D renderings, Direct 3D for 3D renderings; and OpenGL on Mac OS. If Direct2D is not available, FireMonkey will fall back to GDI+ to render the GUI.

Here is a video by Andreano Lanusse demoing 3D capabilities of FireMonkey on Windows, Mac OS, and iOS :

You can also read more about FireMonkey on Andreano’s weblog (Do not miss the comments) :

A little bit about FireMonkey and Delphi XE2

However that is not the whole story; in XE2 we don’t need to deal with a separate set of components as data-aware components. Now in XE2 we will have Live Binding. It means we can bind any data source to any visual control. If you are familiar with .NET controls, you probably saw this binding property. Now the same thing exists in Delphi too.

What’s more, DataSnap and DBX are also enhanced; for DataSnap, AFAIK, proxy class generators are added for many platforms (i.e. Android, iOS, JavaScript, .NET, BlackBerry, etc.). Also I heard some features are added for deployment to could.  For DBX, it seems a driver for ODBC is added.

Beside all of these new features, the popular reporting tool, FastReport, will be shipped by default with Delphi XE2 too.

There must be many enhancements and additions to Delphi RTL too, but I haven’t heard anything about them yet. So we have to wait for other worldwide tours Embarcadero is conducting in August to get more detail information about this exciting release.

It seems XE2 might be the most significant Delphi release in the past decade. It is not officially announced when XE2 will be released, but I can guess it will be some time in September.

Also many of them try to hide the constructor under protected visibility, assuming it would prohibit users from instantiating the class, and forcing them to use the defined method for accessing the singleton instance. I can’t realize what was the rationale behind hiding the constructor, because all Delphi classes are inherited from TObject, and it already has a default Create constructor defined as public, so a user can always call that Create method to instantiate a new object and getting around your singleton implementation.

A few months ago when I was looking for a singleton implementation in Delphi which does not use old writable consts or global variables; I found a blog post by Yanniel Alvarez Alfonso, implementing Singleton pattern using class variables, but there was still the problem of hiding constructors, so I wrote a comment there, telling him that hiding the constructor is not a good idea; and instead of that, he should override TObject.NewInstance method. He appreciated the note, and changed his code to reflect that.

Today I needed to implement Singleton again, but I was too lazy to write it, so I searched for it in my source codes, but didn’t find my own code! I tried my favorite modeling tool; ModelMaker, but their Singleton pattern implementation was the same old-style writable const technique (even in the new ModelMaker 11). Eventually I decided to write it again, and save it as a code template in ModelMaker to use it later when I need it and I am not in the mood of writing it again and again

Singleton Implementation

Here is my implementation of a singleton class:

unit uSingleton;

interface

uses
  Windows;

type
  TSingleton = class sealed(TObject)
  strict private
    class var
      _Instance: TSingleton;
    /// This lock assures us that our singleton instance will be
    /// created only once in a multi-threaded environment.
    CreationLock: RTL_CRITICAL_SECTION;
    class function GetInstance: TSingleton; static; inline;
  private
    procedure InitInstanceFields;
  public
    class constructor ClassCreate;
    constructor Create;
    class destructor ClassDestroy;
    destructor Destroy; override;
    class function NewInstance: TObject; override; final;
    class property Instance: TSingleton read GetInstance;
  end;

implementation

{ TSingleton }
class constructor TSingleton.ClassCreate;
begin
  InitializeCriticalSection(CreationLock);
end;

constructor TSingleton.Create;
begin
  inherited;

end;

class destructor TSingleton.ClassDestroy;
begin
  /// If singleton instance is not destroyed by user, destroy it automatically.
  if Assigned(_Instance) then
  begin
    _Instance.Free;
    _Instance := nil;
  end;
  DeleteCriticalSection(CreationLock);
end;

destructor TSingleton.Destroy;
begin
  /// Make the singleton instance nil before destroying it.
  /// This way, next time Instance property is accessed, a
  /// new instance will be created.
  _Instance := nil;
  inherited;
end;

class function TSingleton.GetInstance: TSingleton;
begin
  Result := Self.Create;
end;

procedure TSingleton.InitInstanceFields;
begin
  { TODO : Initialize your instance here}
end;

class function TSingleton.NewInstance: TObject;
begin
  /// New instance is called when a new instance is being created.
  /// We first check if the singleton instance is assigned, if
  /// it is not assigned yet, we let NewInstance assign a new
  /// instance; Otherwise, we make it to return our already assigned
  /// singleton object.
  /// This way we will always have a single instance of the class
  /// even if user calls Create() method of our class.
  if not Assigned(_Instance) then
  begin
    EnterCriticalSection(CreationLock);
    try
      _Instance := inherited NewInstance as Self;
      _Instance.InitInstanceFields;
    finally
      LeaveCriticalSection(CreationLock);
    end;
  end;

  Result := _Instance;
end;

end.

The important piece of this code is overriding TObject.NewInstance method. TObject.NewInstance is defined as a virtual class function. It is responsible for allocating memory for an instance of a class and returning a pointer to the allocated memory. NewInstance is called by all constructors automatically. So, if you override NewInstance method, you can control how instances of a class are allocated. What we do here is to make sure NewInstance allocates memory for our class instances only once, and if an instance is already created, it returns a pointer to that instance rather than allocating new memory. This way, we do not need to hide our constructors, because even if you call constructor of your class, it relays on NewInstance for its memory allocation, and will always return the same singleton instance.

WARNING: Take note that if you have any initialization code in your constructor, calling it more than once will execute those initialization codes again, so you’d better take care of that in your constructor; otherwise, you might end up having memory leaks or losing the data stored in that singleton instance! To avoid that, I added a new method called InitInstanceFields which is called by NewInstance whenever the singleton instance is being assigned. You can put your initialization codes in that method.

As it is obvious, this code won’t compile in older version of Delphi, because we are using class constructor\destructor, strict private visibility, and class var.  You need Delphi 2010 or newer versions to compile this code. Class constructors and class destructors were introduced in Delphi 2010 as an object-oriented replacement for unit initialization and finalization sections. They work almost the same as initialization and finalization sections, but have a big advantage over those old unit sections; a unit initialization or finalization section is always executed, either you use the corresponding classes or not. On the other hand, a class constructor or destructor is executed only if you use a class or one of its instances in your code. If you do not use the class, its class constructor or destructors won’t execute. That is how (along with DLL delay loading) Delphi team added gesture support to existing Delphi controls without such a big overhead in Delphi 2010. You can read more about class constructors and destructors in this blog post by Allen Bauer.

ModelMaker Code Template

OK, now that we have the code, we can change it a little to turn it in to a ModelMaker code templates. Code templates are custom patterns which can be defined by the user, and applied on an element in ModelMaker. Our template is simple, the only change we need to make is using <!ClassName!> macro. This macro will be expanded automatically to the actual class name by ModelMaker. Once our code is ready, we can open ModelMaker, go to View | Patterns menu (Shift + F7), and once Patterns dialog is open, right-click on an empty area of the dialog, and select Register Code Template from the context menu. ModelMaker will ask for the template source file. We will give it address of our template source file, and a template name (I used “Singleton Class”). That’s it! Now our new template is registered and available in Templates tab of Patterns dialog. Select a class in your model, and open Patterns dialog, go to Templates tab, and click on your template button. ModelMaker will automatically apply it to your class, making your class a singleton class.

Here is my ModelMaker template:

unit Singleton;

interface

uses Windows;

type
  TCodeTemplate = class sealed(TObject)
  strict private
    class var _Instance: <!ClassName!>;
    class var CreationLock : RTL_CRITICAL_SECTION;
    class function GetInstance: <!ClassName!>; static; inline;
  private
    procedure InitInstanceFields;
  public
    constructor Create;
    destructor Destroy; override;
    class constructor ClassCreate;
    class destructor ClassDestroy;
    class function NewInstance: TObject; override; final;
    class property Instance: <!ClassName!> read GetInstance;
  end;

implementation

constructor TCodeTemplate.Create;
begin
  inherited;

end;

destructor TCodeTemplate.Destroy;
begin
  _Instance := nil;
  inherited;
end;

class constructor TCodeTemplate.ClassCreate;
begin
  InitializeCriticalSection(CreationLock);
end;

class destructor TCodeTemplate.ClassDestroy;
begin
  if Assigned(_Instance) then
  begin
    _Instance.Free;
    _Instance := nil;
  end;
  DeleteCriticalSection(CreationLock);
end;

class function TCodeTemplate.GetInstance: <!ClassName!>;
begin
  Result := Self.Create;
end;

procedure TCodeTemplate.InitInstanceFields;
begin
  { TODO : Initialize your instance here}
end;

class function TCodeTemplate.NewInstance: TObject;
begin
  if not Assigned(_Instance) then
  begin
    EnterCriticalSection(CreationLock);
    try
      _Instance := inherited NewInstance as Self;
      _Instance.InitInstanceFields;
    finally
      LeaveCriticalSection(CreationLock);
    end;
  end;

  Result := _Instance;
end;

end.

Have fun

Update 1: I added a critical section to make the implementation thread-safe (refer to David’s comment). The code for creating a new singleton instance is protected by a critical section to make sure multiple threads will not create multiple instances of the class if they are accessing Instance property for the first time simultaneously.

Update 2: There were some flaws in the sample source code and a bug in initializing instance fields. I updated the source code to fix those issues (Refer to Arthur’s comment and my reply to him).

در این نوشته قصد دارم درباره چگونگی دانلود از مارکت آمازون برای اندروید بنویسم…

حدود یک ماهی میشه که شرکت آمازون یک فروشگاه آنلاین برای نرم افزارهای سیستم عامل اندروید افتتاح کرده. هر چند این فروشگاه به اندازه فروشگاه اندروید مارکت گوگل نرم افزار نداره، و به اندازه اون هم همه گیر نیست، اما با توجه به عظمت شرکت آمازون، و تخصص آن در فروشگاه های آنلاین، و محتوای متنوعی که این شرکت ارائه میکنه، و توجه روز افزون این شرکت به تبلت ها؛ میشه امیدوار بود که این فروشگاه به زودی به عنوان رقیبی برای اندروید مارکت شرکت گوگل تبدیل بشه، و مانعی بر سر راه انحصار طلبی تدریجی گوگل در بازار اندروید بشه. در حال حاضر، آمازون هر روز یک نرم افزار تجاری را به طور رایگان در اختیار کاربرانش قرار میده، که همین خودش تبلیغ خوبی برای این سرویس هست.

مارکت آمازون از دو طریق وب سای و همچنین از طریق نرم افزار اختصاصی این شرکت در دسترس هست. کاربر میتونه از طریق وب سایت آمازون یا نرم افزار مارکت آمازون لیست نرم افزارها را مرور کنه، و نرم افزار دلخواه اش را خریداری کنه. در این حالت، نرم افزار مربوطه به لیست آنلاین نرم افزارهای کاربر در سایت آمازون افزوده میشه، و کاربر میتونه از طریق نرم افزار مارکت آمازون بر روی دستگاه اندروید خود، نرم افزار های خود را دانلود کرده و بر روی دستگاه نصب کنه. مارکت فعلی امکان جستجو در لیست نرم افزارها، مشاهده دسته بندی نرم افزار، مشاهده صد نرم افزار رایگان و تجاری برتر، ایجاد Wish List، و ارائه لیست نرم افزارهای پیشنهادی بر اساس علایق شما را فراهم میکنه. البته متاسفانه نرم افزار مارکت آمازون که بر روی دستگاه نصب میشه، امکان شناسایی نرم افزارهای نصب شده فعلی را نداره، و اگر بخواید نسخه جدیدی از یکی از نرم افزارهای فعلی تان را نصب کنید، آمازون قبل از نصب نسخه جدید، نسخه قبلی را حذف میکنه، اما بعد از اینکه یک بار نرم افزار مربوطه با مارکت آمازون نصب شد، دفعات بعد، می تونید بدون مشکل آن نرم افزار را توسط مارکت آمازون آپدیت کنید.

محدودیت فعلی دانلود

بزرگترین مشکل فعلی مارکت آمازون برای اندروید، محدود کردن کاربران آن به کاربران آمریکایی هست؛ یعنی فعلا به طور رسمی، مارکت آمازون فقط به کاربرانی که در آمریکا زندگی می کنند، سرویس ارائه میکنه، و کاربرانی که قصد دانلود از سایر نقاط جهان را داشته باشند، قادر نخواهند بود که از این مارکت دانلود کنند. در این حالت، برای ما کاربران ایرانی اندروید، فرق خاصی بین مارکت گوگل و آمازون وجود نخواهد داشت؛ در هر دو حالت، امکان دانلود نرم افزار برای ما فراهم نیست.

اما برخلاف گوگل، شرکت آمازون کنترل خاصی بر روی دستگاه های اندروید فروخته شده نداره، و به اندازه گوگل هم محدودیت برای کاربران ایجاد نمیکنه. در واقع دانلود نرم افزار مارکت آمازون برای اندروید توسط هر کاربری حتی ایرانی امکان پذیر هست، و ثبت نام در سایت آمازون هم آزاد هست؛ اما در هنگام دانلود، آمازون از شما میخواد که اطلاعات مربوط به بخش ۱-Click Purchase را در خصوصیات کاربری خودتان وارد کنید. این اطلاعات شامل آدرس شما، و اطلاعات کارت اعتباری شما میشه، و اگر اطلاعات معتبری برای کارت اعتباری وارد نکنید، یا آدرس شما خارج از ایالات متحده آمریکا باشه، امکان دانلود برای شما فراهم نخواهد شد.

چگونگی دور زدن محدودیت دانلود

همانطور که گفتم، آمازون به اطلاعات معتبر یک کارت اعتباری، و یک آدرس معتبر در داخل آمریکا نیاز داره، تا به شما اجازه دانلود بده. خب اگر یک کارت اعتباری معتبر آمریکایی داشته باشید، مشکلی نیست؛ می تونید هم نرم افزارهای رایگان و هم نرم افزارهای تجاری را از مارکت آمازون دانلود کنید. اما اگر کارت اعتباری آمریکایی نداشته باشید، چطور؟

در واقع شرکت آمازون فقط اعتبار کارت اعتباری را با بررسی الگوی اعداد به کار رفته در شماره کارت اعتباری بررسی میکنه، و اگر شما الگویی از اعداد را به عنوان شماره کارت اعتباری وارد کنید که مشابه یکی از الگوهای استفاده شده توسط شرکت های معتبر کارت اعتباری باشه، آمازون شماره کارت اعتباری شما را قبول میکنه. البته این به معنی آن نیست که با همچین شماره کارت اعتباری می تونید از آمازون خرید کنید، بلکه در زمان خرید یک محصول تجاری، صحت اطلاعات کارت اعتباری شما بررسی میشه، و در اون صورت، شماره جعلی شما جواب نخواهد داد، اما این بررسی فقط برای دانلود نرم افزارهای تجاری صورت میگیره، پس اگر بخواید نرم افزارهای رایگان را دانلود کنید، با همین شماره کارت جعلی هم می تونید این کار را انجام بدید. البته دقت داشته باشید که اگر آمازون متوجه استفاده از شماره کارت جعلی بشه، حساب آمازون شما مسدود خواهد شد!

نرم افزارها و سایت هایی هستند که می تونند برای شما شماره های کارت اعتباری به ظاهر صحیح تولید کنند، یکی از این سایت ها، سایت fakenamegenerator.com هست، که میتونه برای شما نام، آدرس، شماره تلفن، و شماره کارت اعتباری به ظاهر معتبر، ولی در واقع جعلی تولید کنه. دقت داشته باشید که سئولیت استفاده از اینگونه ابزارها با خودتان خواهد بود.

بعد از به دست آوردن یک شماره کارت اعتباری و  آدرس، می تونید با این نام و آدرس در سایت آمازون ثبت نام کنید. بعد از ثبت نام در سایت آمازون، به صفحه مربوط به Appstore for Android برید، و در گوشه بالا سمت راست، در کادر Get Sarted، آدرس ایمیل خود را وارد کنید. و بر روی دکمه Go کلیک کنید. با این کار، لینک دانلود Appstore برای شما ایمیل میشه، و می تونید از طریق اون لینک، فایل apk مربوطه را دریافت، و در دستگاه خودتان نصب کنید.

بعد از نصب برنامه در دستگاه اندریود خود، به سایت آمازون برگردید؛ و به صفحه Your Account برید، و در بخش Settings، گزینه ۱-Click Settings را انتخاب کنید. در این صفحه، از شما اطلاعات کارت اعتباری، آدرس، و تلفن شما درخواست میشه. اطلاعات کارت اعتباری که از طریق سایت fakenamegenerator به دست آوردید را در فیلدهای مربوطه وارد کنید. آدرس خود، شامل کشور، ایالت، شهر، و نام خیابان، را در فیلدهای مربوطه وارد کنید. اگر پس از ثبت آدرس، آمازون از آدرس وارد شده برای خیابان ایراد گرفت، می تونید یک آدرس واقعی در همان شهر را به راحتی با جستجو برای نام آن شهر پیدا کنید، مثلا سایت های مشاور املاک متعددی وجود دارند که آدرس خانه ها و ویلاهای آماده فروش یا کرایه را درج می کنند، یا شرکت های مختلف حاضر در شهر، آدرس خود را در سایت شان درج می کنند. پس می توانید به راحتی یک آدرس معتبر در داخل شهر و ایالت مورد نظر پیدا کنید. اگر آمازون به شما پیشنهاد داد که شاید ZIP Code وارد شده، اشتباه باشه، و منظور شما فلان آدرس هست، همان آدرس پیشنهادی آمازون را  قبول کنید. شماره تلفن جعلی که در مرحله قبل به دست آوردید را هم در کادر مربوط به شماره تلفن وارد کنید، فقط دقت کنید که حتما در ابتدای شماره تلفن، عبارت ۱+ که کد تلفن کشور آمریکا هست، را قید کنید، وگرنه امکان دانلود برای شما فراهم نخواهد شد!

با ذخیره کردن تنظیمات بالا، می توانید در دستگاه اندروید خود برنامه Appstore را اجرا کرده، و در سایت آمازون لاگین کنید، و لیست نرم افزارها را مرور کنید. هر نرم افزاری رایگانی که مایل به دانلود آن هستید را انتخاب کرده، و گزینه Get app را کلیک کنید. با این کار، فرایند دریافت آن فایل شروع خواهد شد. ابتدا آمازون یک فاکتور خرید برای شما ایمیل می کند، و سپس دانلود نرم افزار بر روی دستگاه شروع خواهد شد. بعد از اتمام دانلود، نرم افزار بر روی دستگاه شما نصب می شود.

دانلود با استفاده از کارت اعتباری معتبر غیر آمریکایی

اگر یک کارت اعتباری معتبر، ولی غیر آمریکایی دارید، و قصد خرید محصولات تجاری از مارکت آمازون برای اندروید را دارید، در این مرحله می توانید اطلاعات کارت اعتباری واقعی خودتان را در تنظیمات حساب کاربری خودتان وارد کنید، و از طریق آن به خرید بپردازید؛ چون ظاهرا بررسی آمریکایی بودن آدرس شما فقط یک بار انجام میشه، و تغییر آدرس و شماره کارت اعتباری در مراحل بعدی، تاثیری بر امکان دانلود یا خرید شما نخواهد داشت.

خوش بگذره