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

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.

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 را کلیک کنید. با این کار، فرایند دریافت آن فایل شروع خواهد شد. ابتدا آمازون یک فاکتور خرید برای شما ایمیل می کند، و سپس دانلود نرم افزار بر روی دستگاه شروع خواهد شد. بعد از اتمام دانلود، نرم افزار بر روی دستگاه شما نصب می شود.

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

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

خوش بگذره

Q1: How can we find a module which is running a specific thread, giving a thread ID:

A: First of all, Threads are not assigned to modules, they are assigned to processes. You can find a process which is running the thread, by searching in the list of threads owned by each running process. Here is a sample code:

function FindProcessByThreadID(ID: Cardinal): TProcessItem;
var
  ProcessInfo : TProcessInfo;
  AProcess : TProcessItem;
begin
  Result := nil;
  ProcessInfo := TProcessInfo.Create(nil);
  try
    for AProcess in ProcessInfo.RunningProcesses do
    begin
      if Assigned(AProcess.Threads.FindByID(ID)) then
      begin
        Result := AProcess;
        Exit;
      end;
    end;
  finally
    ProcessInfo.Free;
  end;
end;

FindProcessByThreadID iterates over all running processes, and checks which of them has a thread with the given ID. If a process owns a thread with that ID, it will return that process as a TProcessItem object.

Once you have the process object, you can get more information about the process or the specific thread, or you can kill the process, or suspend the thread. For example:

var
  Process : TProcessItem;
begin
  Process := FindProcessByThreadID(StrToInt(3444));
  if Assigned(Process) then
    ShowMessage(Process.FullPath);
end;

The above code looks for a thread with its ID = 3444, and if it is found, it provides full path of the EXE file for that process.

Q2: How can we get memory consumption for a given process?

A: You can read memory info for a given process using TProcessItem.MemoryInfo. It provides different info about the memory the process is consuming. Here is an example for reading memory info of Google Chrome process while it is running :

var
  ProcessInfo : TProcessInfo;
  AProcess : TProcessItem;
begin
  ProcessInfo := TProcessInfo.Create(nil);
  try
    AProcess := ProcessInfo.RunningProcesses.FindByName('Chrome.exe');
    if Assigned(AProcess) then
      ShowMessage(Format('WorkingSet Size = %d, Peak WorkingSet Size = %d',
                         [AProcess.MemoryInfo.WorkingSetSize,
                          AProcess.MemoryInfo.PeakWorkingSetSize]));
  finally
    ProcessInfo.Free;
  end;
end;

First we search for Chrome.exe process among running processes. Once the process is found, we read its current working set size, and pick working set size through MemoryInfo property, and show them in a message box. The values returned are in Bytes.

Q3: How can we get process base priority class or change it?

A: You can access base priority class for a given process or modify it (added in version 1.3), using TProcessItem.

PriorityClassBase. Be careful, adjusting a base priority class of a given process inappropriately might make other processes unresponsive! Here is a example code:

var
  ProcessInfo : TProcessInfo;
  AProcess : TProcessItem;
begin
  ProcessInfo := TProcessInfo.Create(nil);
  try
    AProcess := ProcessInfo.RunningProcesses.FindByName('firefox.exe');
    if Assigned(AProcess) then
      AProcess.PriorityClassBase := BELOW_NORMAL_PRIORITY_CLASS;
  finally
    ProcessInfo.Free;
  end;
end;

You can also change each priority of  each thread within a process by setting BasePriority property of that TThreadItem instace.

Q4: How can I check if a process is 64-bit?

A: You can check this by reading TProcessItem.Is64Bits property.

Q5: How can I get CPU usage for a given process?

A: You can get CPU usage by reading TProcessItem.CPUUsage property.

I hope these few answers and sample source codes can help you use Process Info. For other examples of using Process Info, please refer to this post: How to use TProcessInfo

If there is any question regarding using Process Info, or anything about Delphi that you think worth being mentioned in Tips & Tricks section of this website, please contact me, and let me know about it.

Have Fun!

This toolbar provides a nice search box which is able to filter components in the palette based on the search phrase. This toolbar is disabled by default, and is shown when Classic Layout is selected. Here you can see a snapshot of Classic Layout in RAD Studio 2010:

A few weeks ago while I was working with Delphi 2010, I noticed a delay when switching from code view to form designer. The delay was there not only in the complex forms, but also in simple empty forms! It was not a big delay (about 1 second), but since I had to switch between code and form designer view many times, it was really annoying, so I decided to investigate it and find out what is causing this delay.

At first I got suspected to CnPack toolbars in form designer and code view, so I disabled them, but it had no effect on the delay!  Then I went for SysInternals Process Monitor to monitor RAD Studio while switching from code view to form designer. There were many Registry activities regarding to component toolbar. At that time I was thinking about standard Tool Palette in RAD Studio 2010, not the classic component toolbar, because I was not using classic layout.

I tried to hide Tool Palette to see if it fixes the delay, but it didn’t! So I decided to disable its IDE package and see if it fixes the issue. While I was looking into the list of IDE packages in Registry, I found Component Toolbar Package, and I thought this is the package corresponding to Tool Palette. So I removed it from the list of known IDE packages, and restarted RAD Studio 2010; the Tool Palette was still there, BUT the switching delay was gone!

I was wondering if Component Toolbar was not related

to Tool Palette, then what was it related to?! Suddenly I remembered the new classic component toolbar, and switched to Classic Layout. Yes, it was the new classic component toolbar which was using Component Toolbar Package!

Since I don’t use classic view, I simply disabled this IDE package to have a faster switch time from code view to form designer. But still it is weird why this toolbar is being update even when it is not being visible, and why it is making switching from code view to form designer slower. This is definitely a bug in RAD Studio 2010.

How to disable an IDE package:

Here is how you can disable Component Toolbar Package from Registry:

1- Go to HKEY_CURRENT_USER\Software\CodeGear\BDS\7.0\Known IDE Packages.

2- Make a backup by right-clicking on “Known IDE Packages” key, and selecting  Export.

3- Find “$(BDS)\bin\comptoolbar140.bpl” value in “Known IDE Packages” key, and delete it.

4- Run RAD Studio 2010.

Regards

I thought maybe it is a good idea to talk about these components and some of their usages by providing some sample source codes. So I will start with TProcessInfo.

Updating running processes list automatically

TProcessInfo has an internal timer which can update processes list automatically. This timer is controlled by Active, and UpdateInterval properties. Active activates the internal timer, and UpdateInterval specifies update interval. The default value for UpdateInterval is 1000 (1 second).

To update the list manually, and not using the internal timer, you can call UpdateList method.

OnBeforeUpdate and OnAfterUpdate

TProcessInfo has two events. They both are invoked when UpdateList is called, either automatically by internal timer or manually by the programmer.

OnBeforeUpdate is invoked just before updating the list. It has a Cancel parameter which lets you to cancel updating. OnAfterUpdate is invoked when the list is updated. So if you have a control (e.g. a list view) that should show processes list, you can write its updating code in the event-handler of OnAfterUpdate.

Finding a running process

You can iterate over all running processes to find a specific process with specific characteristics, or use FindByID, and FindByName methods to find a process by its Process ID or Process Name:

var
  Process : TProcessItem;
begin
  Process := ProcessInfo1.RunningProcesses.FindByID(1234);
  if not Assigned(Process) then
    ShowMessage('No process found');
end;

Finding a process by its Process ID.

var
  Process : TProcessItem;
begin
  Process := ProcessInfo1.RunningProcesses.FindByName('Project3.exe');
  if not Assigned(Process) then
    ShowMessage('No process found');
end;

Finding a process by its Process Name.

var
  I: Integer;
  MemSize,
  MaxMemSize : Cardinal;
  ProcessName : string;
begin
  MaxMemSize := 0;
  for I := 0 to ProcessInfo1.RunningProcesses.Count - 1 do
  begin
    MemSize := ProcessInfo1.RunningProcesses[i].MemoryInfo.WorkingSetSize;
    if MemSize > MaxMemSize then
    begin
      MaxMemSize := MemSize;
      ProcessName := ProcessInfo1.RunningProcesses[i].ExeFile;
    end;
  end;
  ShowMessage(ProcessName + ‘uses more memory than other processes.’);
end; 

Finding the process which consumes more memory than others.

Terminating a running process

To terminate a running process, you should first find it in the list of running processes, and then call its TerminateProcess method:

 var
  Process : TProcessItem;
begin
  Process := ProcessInfo1.RunningProcesses.FindByName('notepad.exe');
  if Assigned(Process) then
    Process.TerminateProcess;
end;

Retrieving full path of a process

 var
  Process : TProcessItem;
begin
  Process := ProcessInfo1.RunningProcesses.FindByName('notepad.exe');
  if Assigned(Process) then
    ShowMessage(Process.FullPath);
end;

Listing modules which a process loaded

 var
  Process : TProcessItem;
  I: Integer;
begin
  Process := ProcessInfo1.RunningProcesses.FindByName('Project1.exe');
  if  Assigned(Process) then
  begin
    for I := 0 to Process.Modules.Count - 1 do
      Memo1.Lines.Add(Format('%d  : %s',[Process.Modules[i].BaseAddress,
                                         Process.Modules[i].ModuleName]));
  end;
end;

You can access other information about a process (e.g. Threads list, threads count, memory consumption, and so on) in the same way.
TAppInfo works very similar to TProcessInfo. I will try to explain it more with some examples in another article.