Grandstream IP Camera API [in progress]

unit GrandstreamAPI;

interface

uses
  Windows, Classes, SysUtils,
  IdBaseComponent, IdComponent, IdTCPConnection, IdTCPClient, IdHTTP,
  IdAllAuthentications ;

type
  TGrandstreamAPI = class;
  TGsParams = class;
  TGsRequestChannel = class;
  TGsRequestChannelBase = class;
  TGsRequestBase = class;
  TGsAudioVideo = class;
  TGsDevice = class;
  TGsStatus = class;
  TGsMaintenance = class;
  TGsOSD = class;

  TGsRequestResult = (grOkay,grBadRequest,grUnauthorized,grNotFound,
    grServiceUnavailable);

  TGrandstreamAPI = class(TComponent)
  private
    FStream: TStringStream;
    FAddress: String;
    FPort: Integer;
    FPass: String;
    FUser: String;
    FWeb: TIdHTTP;
    FAudioVideo: TGsAudioVideo;
    FDevice: TGsDevice;
    FStatus: TGsStatus;
    FMaintenance: TGsMaintenance;
    function GetURL: String;
    procedure SetAddress(const Value: String);
    procedure SetPort(const Value: Integer);
    procedure SetPass(const Value: String);
    procedure SetUser(const Value: String);
    function Get(const Module: String): TGsRequestResult;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property URL: String read GetURL;
    property AudioVideo: TGsAudioVideo read FAudioVideo;
    property Device: TGsDevice read FDevice;
    property Status: TGsStatus read FStatus;
    property Maintenance: TGsMaintenance read FMaintenance;
  published
    property Address: String read FAddress write SetAddress;
    property Port: Integer read FPort write SetPort;
    property User: String read FUser write SetUser;
    property Pass: String read FPass write SetPass;
  end;

  TGsParams = class(TObject)
  private
    FItems: TStringList;
    function GetItem(const Name: String): String;
    procedure SetItem(const Name, Value: String);
    function GetName(const Index: Integer): String;
  public
    constructor Create;
    destructor Destroy; override;
    function Count: Integer;
    procedure Clear;
    property Items[const Name: String]: String read GetItem write SetItem; default;
    property Names[const Index: Integer]: String read GetName;
  end;

  { Request Base }

  TGsRequestBase = class(TObject)
  private
    FOwner: TGrandstreamAPI;
    FList: TStringList;
    FData: String;
    procedure Next;
    function Check(const V: String): Boolean;
    function ValInt: Integer;
    function ValStr: String;
    function ValBol: Boolean;
  public
    constructor Create(AOwner: TGrandstreamAPI); virtual;
    destructor Destroy; override;
    function Owner: TGrandstreamAPI;
    function Get(const Cmd: String): TGsRequestResult;
    function Items: TStringList;
  end;


  TGsRequestChannel = class(TObject)
  private

  public
    constructor Create(AOwner: TGsRequestChannelBase);
    destructor Destroy; override;
  end;

  TGsRequestChannelClass = class of TGsRequestChannel;

  TGsRequestChannelBase = class(TGsRequestBase)
  private
    FChannels: TList;
    FItemClass: TGsRequestChannelClass;
    function New: TGsRequestChannel;
    function GetChannel(Index: Integer): TGsRequestChannel;
  public
    constructor Create(AOwner: TGrandstreamAPI; const ItemClass: TGsRequestChannelClass);
    destructor Destroy; override;
    function Get(const Cmd: String): TGsRequestResult;
    function Count: Integer;
    procedure ClearChannels;
    property Channels[Index: Integer]: TGsRequestChannel read GetChannel; default;
  end;

  { Audio/Video (1) }

  TGsVideoCodec = (gvcH264,gvcMJPEG);

  TGsBrType = (gvbVBR,gvbCBR);

  TGsAudioCodec = (gacPCMU,gacPCMA,gacG726,gacDisabled,gacAAC);

  TGsAudioChipType = (gctAIC33,gctAIC3104,gctNone);

  TGsNtscPalType = (gptPAL,gtpNTSC);

  TGsPowerFreq = (gpfIndoor50,gpfIndoor60,gpfOutdoor);

  TGsVideoResolution = class(TObject)
  private
    FLength: Integer;
    FWidth: Integer;
    procedure SetLength(const Value: Integer);
    procedure SetWidth(const Value: Integer);
  public
    property Width: Integer read FWidth write SetWidth;
    property Length: Integer read FLength write SetLength;
  end;

  TGsAudioVideoStream = class(TObject)
  private
    FVideoEncoder: TGsVideoCodec;
    FResolution: TGsVideoResolution;
    FVideoBitrate: Integer;
    FBrType: TGsBrType;
    FFramerate: Integer;
    FIFrame: Integer;
    FImageQuality: Integer;
    FAudioEncoder: TGsAudioCodec;
    FAudioBitrate: Integer;
    procedure SetAudioBitrate(const Value: Integer);
    procedure SetAudioEncoder(const Value: TGsAudioCodec);
    procedure SetBitrate(const Value: Integer);
    procedure SetBrType(const Value: TGsBrType);
    procedure SetFramerate(const Value: Integer);
    procedure SetIFrame(const Value: Integer);
    procedure SetImageQuality(const Value: Integer);
    procedure SetVideoEncoder(const Value: TGsVideoCodec);
  public
    constructor Create;
    destructor Destroy; override;
    property VideoEncoder: TGsVideoCodec read FVideoEncoder write SetVideoEncoder;
    property Resolution: TGsVideoResolution read FResolution;
    property VideoBitrate: Integer read FVideoBitrate write SetBitrate;
    property BrType: TGsBrType read FBrType write SetBrType;
    property Framerate: Integer read FFramerate write SetFramerate;
    property IFrame: Integer read FIFrame write SetIFrame;
    property ImageQuality: Integer read FImageQuality write SetImageQuality;
    property AudioEncoder: TGsAudioCodec read FAudioEncoder write SetAudioEncoder;
    property AudioBitrate: Integer read FAudioBitrate write SetAudioBitrate;
  end;

  TGsAudioVideoChannel = class(TGsRequestChannel)
  private
    FHasSecondary: Boolean;
    FChannel: Integer;
    FPrimary: TGsAudioVideoStream;
    FSecondary: TGsAudioVideoStream;
    FMicrophoneVolume: Integer;
    FSpeakerVolume: Integer;
    FAudioLineIn: Boolean;
    FAudioLineOut: Boolean;
    FAudioChipType: TGsAudioChipType;
    FNtscPalType: TGsNtscPalType;
    FPowerFreq: TGsPowerFreq;
    procedure SetAudioChipType(const Value: TGsAudioChipType);
    procedure SetAudioLineIn(const Value: Boolean);
    procedure SetAudioLineOut(const Value: Boolean);
    procedure SetMicrophoneVolume(const Value: Integer);
    procedure SetNtscPalType(const Value: TGsNtscPalType);
    procedure SetPowerFreq(const Value: TGsPowerFreq);
    procedure SetSpeakerVolume(const Value: Integer);
  public
    constructor Create;
    destructor Destroy; override;
    property HasSecondaryStream: Boolean read FHasSecondary;
    property Channel: Integer read FChannel;
    property Primary: TGsAudioVideoStream read FPrimary;
    property Secondary: TGsAudioVideoStream read FSecondary;
    property MicrophoneVolume: Integer read FMicrophoneVolume write SetMicrophoneVolume;
    property SpeakerVolume: Integer read FSpeakerVolume write SetSpeakerVolume;
    property AudioLineIn: Boolean read FAudioLineIn write SetAudioLineIn;
    property AudioLineOut: Boolean read FAudioLineOut write SetAudioLineOut;
    property AudioChipType: TGsAudioChipType read FAudioChipType write SetAudioChipType;
    property NtscPalType: TGsNtscPalType read FNtscPalType write SetNtscPalType;
    property PowerFreq: TGsPowerFreq read FPowerFreq write SetPowerFreq;
  end;

  TGsAudioVideo = class(TGsRequestChannelBase)
  private
    function GetChannel(Index: Integer): TGsAudioVideoChannel;
    function New: TGsAudioVideoChannel;
  public
    constructor Create(AOwner: TGrandstreamAPI);
    destructor Destroy; override;
    function Get: TGsRequestResult;
    property Channels[Index: Integer]: TGsAudioVideoChannel read GetChannel; default;
  end;

  { OSD (2) }

  TGsOSD = class(TGsRequestBase)
  private

  public
    constructor Create(AOwner: TGrandstreamAPI); override;
    destructor Destroy; override;
    function Get: TGsRequestResult;
  end;

  { Network (3) }

  TGsNetwork = class(TGsRequestBase)

  end;

  { Dynamic DNS (4) }

  TGsDynamicDNS = class(TGsRequestBase)

  end;

  { SIP (5) }

  { Date/Time (6) }

  { System Info / Status (7) }

  TGsDDNSState = (gdsDisable,gdsProcessing,gdsSuccess,gdsAcctPassErr,
    gdsServerBlocking,gdsStunServerErr,gdsDBFailed);

  TGsWiFiState = (gwsDisconnected,gwsConnected);

  TGsLedStatus = (glsUnsupported,glsOn,glsOff);

  TGsPPPoEStatus = (gpsDisconnected,gpsConnected);

  TGsStatus = class(TGsRequestBase)
  private
    FProductMode: String;
    FDDNSState: TGsDDNSState;
    FPartNumber: String;
    FCoreVersion: String;
    FBootLoaderVersion: String;
    FFirmwareVersion: String;
    FBaseVersion: String;
    FHardwareVersion: String;
    FCameraType: String;
    FSystemRun: String;
    FPPPoEStatus: TGsPPPoEStatus;
    FLedStatus: TGsLedStatus;
    FWiFiState: TGsWiFiState;
    FPPPoEIP: String;
    FMac: String;
    FDefaultGateway: String;
    FSubnetMask: String;
    FIPAddress: String;
  public
    constructor Create(AOwner: TGrandstreamAPI); override;
    destructor Destroy; override;
    function Get: TGsRequestResult;
    function DDNSStateStr: String;
    function WiFiStateStr: String;
    function LedStatusStr: String;
    function PPPoEStatusStr: String;
    property ProductMode: String read FProductMode;
    property HardwareVersion: String read FHardwareVersion;
    property PartNumber: String read FPartNumber;
    property BootLoaderVersion: String read FBootLoaderVersion;
    property CoreVersion: String read FCoreVersion;
    property BaseVersion: String read FBaseVersion;
    property FirmwareVersion: String read FFirmwareVersion;
    property CameraType: String read FCameraType;
    property DDNSState: TGsDDNSState read FDDNSState;
    property WiFiState: TGsWiFiState read FWiFiState;
    property SystemRun: String read FSystemRun;
    property Mac: String read FMac;
    property LedStatus: TGsLedStatus read FLedStatus;
    property PPPoEIP: String read FPPPoEIP;
    property PPPoEStatus: TGsPPPoEStatus read FPPPoEStatus;
    property IPAddress: String read FIPAddress;
    property SubnetMask: String read FSubnetMask;
    property DefaultGateway: String read FDefaultGateway;
  end;

  { Account Management (8) }

  { SMTP Email (9) }

  { FTP (10) }

  { PTZ (11) }

  { Alarm Event (12) }

  { Motion Detection (13) }

  { System Log (14) }

  { Storage (15) }

  { Maintenance (16) }

  TGsUpdateVia = (guvTFTP,guvHTTP,guvHTTPS);

  TGsMaintenance = class(TGsRequestBase)
  private
    FUpdateVia: TGsUpdateVia;
    FUpgradeConfigServerPath: String;
    FUpgradeInterval: Integer;
    FUpgradeConfigXmlPassword: String;
    FUpgradeServerPath: String;
    FUpgradeAutomatic: Boolean;
  public
    constructor Create(AOwner: TGrandstreamAPI); override;
    destructor Destroy; override;
    function Get: TGsRequestResult;
    procedure Restart;
    procedure Restore;
    property UpdateVia: TGsUpdateVia read FUpdateVia;
    property UpgradeServerPath: String read FUpgradeServerPath;
    property UpgradeConfigServerPath: String read FUpgradeConfigServerPath;
    property UpgradeConfigXmlPassword: String read FUpgradeConfigXmlPassword;
    property UpgradeAutomatic: Boolean read FUpgradeAutomatic;
    property UpgradeInterval: Integer read FUpgradeInterval;
  end;

  { Video Control (17) }

  TGsVideoControl = class(TGsRequestBase)

  end;

  { WiFi (18) }

  { System Settings / Device (19) }

  TGsAlarmType = (gatNormalOpen,gatNormalClose);

  TGsAlarmStatus = (gasOpen,gasClose);

  TGsAlarmOutputTime = (gao0,gao5,gao15,gao30,gao60,gao180,gao300,gao600,gao900,gao1800);

  TGsGpioPinMultiplex = (gpmNone,gpmControl,gpmAlarmIO);

  PGsDeviceInfo = ^TGsDeviceInfo;
  TGsDeviceInfo = record
    Channel: Integer;
    AlarmInType: TGsAlarmType;
    AlarmOutType: TGsAlarmType;
    AlarmInStatus: TGsAlarmStatus;
    AlarmOutStatus: TGsAlarmStatus;
    AlarmOutputTime: TGsAlarmOutputTime;
    GpioPinMultiplex: TGsGpioPinMultiplex;
  end;

  TGsDevice = class(TGsRequestBase)
  private
    FChannels: Array of PGsDeviceInfo;
    FDeviceName: String;
    function GetChannel(Index: Integer): PGsDeviceInfo;
    procedure ClearChannels;
    procedure SetDeviceName(const Value: String);
  public
    constructor Create(AOwner: TGrandstreamAPI); override;
    destructor Destroy; override;
    function Get: TGsRequestResult;
    function Count: Integer;
    property Channels[Index: Integer]: PGsDeviceInfo read GetChannel; default;
    property DeviceName: String read FDeviceName write SetDeviceName;
  end;

  { PPPoE (20) }

  { Snapshot (21) }

  { Language (22) }

  { Decode (23) }

  { Stream (24) }

  { CMOS (25) }

  { 4*D1 (26) }

  { Alarm Server (27) }

  { Recording (28) }



implementation

const
  CAMERA_URL = 'http://%s:%d/';
  // http://user:pass@address:port/

function EncodeUrl(source: string): string;
 var i:integer;
begin
   result := '';
   for i := 1 to length(source) do
       if not (source[i] in ['A'..'Z','a'..'z','0','1'..'9','-','_','~','.']) then result := result + '%'+inttohex(ord(source[i]),2) else result := result + source[i];
end;

function IntToResult(const R: Integer): TGsRequestResult;
begin
  case R of
    200: Result:= grOkay;
    400: Result:= grBadRequest;
    401: Result:= grUnauthorized;
    404: Result:= grNotFound;
    503: Result:= grServiceUnavailable;
  end;
end;

function ResultToInt(const R: TGsRequestResult): Integer;
begin
  case R of
    grOkay:                 Result:= 200;
    grBadRequest:           Result:= 400;
    grUnauthorized:         Result:= 401;
    grNotFound:             Result:= 404;
    grServiceUnavailable:   Result:= 503;
  end;
end;

{ TGrandstreamAPI }

constructor TGrandstreamAPI.Create(AOwner: TComponent);
begin
  inherited;
  FStream:= TStringStream.Create;
  FWeb:= TIdHTTP.Create(nil);
  FWeb.ProtocolVersion:= pv1_0;
  FWeb.Request.Username:= FUser;
  FWeb.Request.Password:= FPass;
  FWeb.HTTPOptions:= FWeb.HTTPOptions + [hoInProcessAuth];
  FAudioVideo:= TGsAudioVideo.Create(Self);
  FDevice:= TGsDevice.Create(Self);
  FStatus:= TGsStatus.Create(Self);
  FMaintenance:= TGsMaintenance.Create(Self);

end;

destructor TGrandstreamAPI.Destroy;
begin

  FMaintenance.Free;
  FStatus.Free;
  FDevice.Free;
  FAudioVideo.Free;
  FWeb.Free;
  FStream.Free;
  inherited;
end;

function TGrandstreamAPI.GetURL: String;
begin
  Result:= Format(CAMERA_URL, [FAddress,FPort]);
end;

procedure TGrandstreamAPI.SetAddress(const Value: String);
begin
  FAddress := Value;
end;

procedure TGrandstreamAPI.SetPass(const Value: String);
begin
  FPass := Value;
end;

procedure TGrandstreamAPI.SetPort(const Value: Integer);
begin
  FPort := Value;
end;

procedure TGrandstreamAPI.SetUser(const Value: String);
begin
  FUser := Value;
end;

function TGrandstreamAPI.Get(const Module: String): TGsRequestResult;
var
  U: String;
begin

  U:= URL+'/goform/'+Module+'?cmd=get';

  FWeb.Request.UserAgent:= 'JD Grandstream API';
  FWeb.Request.Username:= FUser;
  FWeb.Request.Password:= FPass;

  FWeb.Get(U, FStream);

  Result:= grOkay;

  FStream.Position:= 0;

end;

{ TGsParams }

constructor TGsParams.Create;
begin
  FItems:= TStringList.Create;
end;

destructor TGsParams.Destroy;
begin
  FItems.Free;
  inherited;
end;

procedure TGsParams.Clear;
begin
  FItems.Clear;
end;

function TGsParams.Count: Integer;
begin
  Result:= FItems.Count;
end;

function TGsParams.GetItem(const Name: String): String;
begin
  Result:= FItems.Values[Name];
end;

function TGsParams.GetName(const Index: Integer): String;
begin
  Result:= FItems.Names[Index];
end;

procedure TGsParams.SetItem(const Name, Value: String);
begin
  FItems.Values[Name]:= Value;
end;

{ TGsRequestBase }

constructor TGsRequestBase.Create(AOwner: TGrandstreamAPI);
begin
  FOwner:= AOwner;
  FList:= TStringList.Create;
end;

destructor TGsRequestBase.Destroy;
begin
  FList.Free;
  inherited;
end;

function TGsRequestBase.Get(const Cmd: String): TGsRequestResult;
begin
  FOwner.Get(Cmd);
  FList.Text:= Fowner.FStream.DataString;
end;

function TGsRequestBase.Items: TStringList;
begin
  Result:= FList;
end;

function TGsRequestBase.Owner: TGrandstreamAPI;
begin
  Result:= FOwner;
end;

procedure TGsRequestBase.Next;
begin
  FData:= Items[0];
  Items.Delete(0);
end;

function TGsRequestBase.Check(const V: String): Boolean;
begin
  Result:= Pos(V+'=', FData) = 1;
end;

function TGsRequestBase.ValStr: String;
var
  P: Integer;
begin
  P:= Pos('=', FData);
  Result:= Copy(FData, P+1, Length(FData));
end;

function TGsRequestBase.ValInt: Integer;
begin
  Result:= StrToIntDef(ValStr, 0);
end;

function TGsRequestBase.ValBol: Boolean;
begin
  Result:= ValInt = 1;
end;

{ TGsRequestChannelBase }

constructor TGsRequestChannelBase.Create(AOwner: TGrandstreamAPI; const ItemClass: TGsRequestChannelClass);
begin
  inherited Create(AOwner);
  FChannels:= TList.Create;
  FItemClass:= ItemClass;
end;

destructor TGsRequestChannelBase.Destroy;
begin
  ClearChannels;
  FChannels.Free;
  inherited;
end;

procedure TGsRequestChannelBase.ClearChannels;
begin
  while FChannels.Count > 0 do begin
    TGsRequestChannel(FChannels[0]).Free;
    FChannels.Delete(0);
  end;
end;

function TGsRequestChannelBase.Count: Integer;
begin
  Result:= FChannels.Count;
end;

function TGsRequestChannelBase.Get(const Cmd: String): TGsRequestResult;
begin
  Result:= inherited Get(Cmd);
end;

function TGsRequestChannelBase.GetChannel(Index: Integer): TGsRequestChannel;
begin
  Result:= TGsRequestChannel(FChannels[Index]);
end;

function TGsRequestChannelBase.New: TGsRequestChannel;
begin
  Result:= FItemClass.Create(Self);
  FChannels.Add(Result);
end;

{ TGsRequestChannel }

constructor TGsRequestChannel.Create(AOwner: TGsRequestChannelBase);
begin

end;

destructor TGsRequestChannel.Destroy;
begin

  inherited;
end;

{ TGsVideoResolution }

procedure TGsVideoResolution.SetLength(const Value: Integer);
begin
  FLength := Value;
end;

procedure TGsVideoResolution.SetWidth(const Value: Integer);
begin
  FWidth := Value;
end;

{ TGsAudioVideoStream }

constructor TGsAudioVideoStream.Create;
begin
  FResolution:= TGsVideoResolution.Create;
end;

destructor TGsAudioVideoStream.Destroy;
begin
  FResolution.Free;
  inherited;
end;

procedure TGsAudioVideoStream.SetAudioBitrate(const Value: Integer);
begin
  FAudioBitrate := Value;
end;

procedure TGsAudioVideoStream.SetAudioEncoder(const Value: TGsAudioCodec);
begin
  FAudioEncoder := Value;
end;

procedure TGsAudioVideoStream.SetBitrate(const Value: Integer);
begin
  FVideoBitrate := Value;
end;

procedure TGsAudioVideoStream.SetBrType(const Value: TGsBrType);
begin
  FBrType := Value;
end;

procedure TGsAudioVideoStream.SetFramerate(const Value: Integer);
begin
  FFramerate := Value;
end;

procedure TGsAudioVideoStream.SetIFrame(const Value: Integer);
begin
  FIFrame := Value;
end;

procedure TGsAudioVideoStream.SetImageQuality(const Value: Integer);
begin
  FImageQuality := Value;
end;

procedure TGsAudioVideoStream.SetVideoEncoder(const Value: TGsVideoCodec);
begin
  FVideoEncoder := Value;
end;

{ TGsAudioVideoChannel }

constructor TGsAudioVideoChannel.Create;
begin
  FPrimary:= TGsAudioVideoStream.Create;
  FSecondary:= TGsAudioVideoStream.Create;
end;

destructor TGsAudioVideoChannel.Destroy;
begin
  FSecondary.Free;
  FPrimary.Free;
  inherited;
end;

procedure TGsAudioVideoChannel.SetAudioChipType(const Value: TGsAudioChipType);
begin
  FAudioChipType := Value;
end;

procedure TGsAudioVideoChannel.SetAudioLineIn(const Value: Boolean);
begin
  FAudioLineIn := Value;
end;

procedure TGsAudioVideoChannel.SetAudioLineOut(const Value: Boolean);
begin
  FAudioLineOut := Value;
end;

procedure TGsAudioVideoChannel.SetMicrophoneVolume(const Value: Integer);
begin
  FMicrophoneVolume := Value;
end;

procedure TGsAudioVideoChannel.SetNtscPalType(const Value: TGsNtscPalType);
begin
  FNtscPalType := Value;
end;

procedure TGsAudioVideoChannel.SetPowerFreq(const Value: TGsPowerFreq);
begin
  FPowerFreq := Value;
end;

procedure TGsAudioVideoChannel.SetSpeakerVolume(const Value: Integer);
begin
  FSpeakerVolume := Value;
end;

{ TGsAudioVideo }

constructor TGsAudioVideo.Create(AOwner: TGrandstreamAPI);
begin
  inherited Create(AOwner, TGsAudioVideoChannel);

end;

destructor TGsAudioVideo.Destroy;
begin

  inherited;
end;

function TGsAudioVideo.GetChannel(Index: Integer): TGsAudioVideoChannel;
begin
  Result:= TGsAudioVideoChannel(inherited Channels[Index]);
end;

function TGsAudioVideo.New: TGsAudioVideoChannel;
begin
  Result:= TGsAudioVideoChannel(inherited New);
end;

function TGsAudioVideo.Get: TGsRequestResult;
var
  I: TGsAudioVideoChannel;
  X: Integer;
begin
  ClearChannels;
  try
    Result:= inherited Get('audio_video');;
    X:= -1;
    while Items.Count > 0 do begin
      Next;
      if Check('channel') then begin
        Inc(X);
        I:= New;
        I.FChannel:= X;
        I.FHasSecondary:= False;
      end else
      if Check('video.primary.encoder') then begin
        case ValInt of
          96: I.Primary.FVideoEncoder:= gvcH264;
          26: I.Primary.FVideoEncoder:= gvcMJPEG;
        end;
      end else
      if Check('video.primary.resolution') then begin
        //I.Primary.Resolution:= StrToRes(ValStr);
        //REDO
      end else
      if Check('video.primary.bitrate') then begin
        I.Primary.FVideoBitrate:= ValInt;
      end else
      if Check('video.primary.brtype') then begin
        case ValInt of
          0: I.Primary.FBrType:= gvbVBR;
          1: I.Primary.FBrType:= gvbCBR;
        end;
      end else
      if Check('video.primary.framerate') then begin
        I.Primary.FFramerate:= ValInt;
      end else
      if Check('video.primary.iframe') then begin
        I.Primary.FIFrame:= ValInt;
      end else
      if Check('video.primary.imagequality') then begin
        I.Primary.FImageQuality:= ValInt;
      end else
      if Check('audio.primary.encoder') then begin
        case ValInt of
          0: I.Primary.FAudioEncoder:= gacPCMU;
          1: I.Primary.FAudioEncoder:= gacPCMA;
          2: I.Primary.FAudioEncoder:= gacG726;
          3: I.Primary.FAudioEncoder:= gacDisabled;
          4: I.Primary.FAudioEncoder:= gacAAC;
        end;
      end else
      if Check('audio.primary.bitrate') then begin
        I.Primary.FAudioBitrate:= ValInt;
      end else
      if Check('video.secondary.encoder') then begin
        I.FHasSecondary:= True;
        case ValInt of
          96: I.Secondary.FVideoEncoder:= gvcH264;
          26: I.Secondary.FVideoEncoder:= gvcMJPEG;
        end;
      end else
      if Check('video.secondary.resolution') then begin
        //I.Secondary.Resolution:= StrToRes(ValStr);
        //REDO
      end else
      if Check('video.secondary.bitrate') then begin
        I.Secondary.FVideoBitrate:= ValInt;
      end else
      if Check('video.secondary.brtype') then begin
        case ValInt of
          0: I.Secondary.FBrType:= gvbVBR;
          1: I.Secondary.FBrType:= gvbCBR;
        end;
      end else
      if Check('video.secondary.framerate') then begin
        I.Secondary.FFramerate:= ValInt;
      end else
      if Check('video.secondary.iframe') then begin
        I.Secondary.FIFrame:= ValInt;
      end else
      if Check('video.secondary.imagequality') then begin
        I.Secondary.FImageQuality:= ValInt;
      end else
      if Check('audio.secondary.encoder') then begin
        case ValInt of
          0: I.Secondary.FAudioEncoder:= gacPCMU;
          1: I.Secondary.FAudioEncoder:= gacPCMA;
          2: I.Secondary.FAudioEncoder:= gacG726;
          3: I.Secondary.FAudioEncoder:= gacDisabled;
          4: I.Secondary.FAudioEncoder:= gacAAC;
        end;
      end else
      if Check('audio.secondary.bitrate') then begin
        I.Secondary.FAudioBitrate:= ValInt;
      end else
      if Check('audio.microphone.volume') then begin
        I.FMicrophoneVolume:= ValInt;
      end else
      if Check('audio.speaker.volume') then begin
        I.FSpeakerVolume:= ValInt;
      end else
      if Check('audio.linein') then begin
        case ValInt of
          0: I.FAudioLineIn:= False;
          1: I.FAudioLineIn:= True;
        end;
      end else
      if Check('audio.lineout') then begin
        case ValInt of
          0: I.FAudioLineOut:= False;
          1: I.FAudioLineOut:= True;
        end;
      end else
      if Check('audio.chip.type') then begin
        case ValInt of
          0: I.FAudioChipType:= gctAIC33;
          1: I.FAudioChipType:= gctAIC3104;
          $FF: I.FAudioChipType:= gctNone;
        end;
      end else
      if Check('ntscpal.type') then begin
        case ValInt of
          50: I.FPowerFreq:= gpfIndoor50;
          60: I.FPowerFreq:= gpfIndoor60;
          61: I.FPowerFreq:= gpfOutdoor;
        end;
      end else begin
        //Unrecognized property
      end;
    end;

  except
    on e: exception do begin

    end;
  end;
end;

{ TGsStatus }

constructor TGsStatus.Create(AOwner: TGrandstreamAPI);
begin
  inherited;

end;

function TGsStatus.DDNSStateStr: String;
begin

end;

destructor TGsStatus.Destroy;
begin

  inherited;
end;

function TGsStatus.Get: TGsRequestResult;
var
  T: String;
begin
  try
    FLedStatus:= glsUnsupported;
    Result:= inherited Get('systeminfo');
    while Items.Count > 0 do begin
      Next;
      if Check('productmode') then begin
        FProductMode:= ValStr;
      end else
      if Check('hardwareversion') then begin
        FHardwareVersion:= ValStr;
      end else
      if Check('partnumber') then begin
        FPartNumber:= ValStr;
      end else
      if Check('bootloaderversion') then begin
        FBootloaderVersion:= ValStr;
      end else
      if Check('coreversion') then begin
        FCoreVersion:= ValStr;
      end else
      if Check('baseversion') then begin
        FBaseVersion:= ValStr;
      end else
      if Check('firmwareversion') then begin
        FFirmwareVersion:= ValStr;
      end else
      if Check('cameratype') then begin
        T:= Trim(Items[0]);
        Items.Delete(0);
        T:= T + ' ' + Trim(Items[0]);
        Items.Delete(0);
        FCameraType:= T;
      end else
      if Check('ddnsstate') then begin
        case ValInt of
          0: FDDNSState:= gdsDisable;
          1: FDDNSState:= gdsProcessing;
          2: FDDNSState:= gdsSuccess;
          3: FDDNSState:= gdsAcctPassErr;
          4: FDDNSState:= gdsServerBlocking;
          5: FDDNSState:= gdsStunServerErr;
          6: FDDNSState:= gdsDBFailed;
        end;
      end else
      if Check('wifistate') then begin
        case ValInt of
          0: FWiFiState:= gwsDisconnected;
          1: FWiFiState:= gwsConnected;
        end;
      end else
      if Check('systemrun') then begin
        FSystemRun:= ValStr;
      end else
      if Check('mac') then begin
        FMac:= ValStr;
      end else
      if Check('ledstatus') then begin
        case ValInt of
          0: FLedStatus:= glsOn;
          1: FLedStatus:= glsOff;
        end;
      end else
      if Check('pppoe.ip') then begin
        FPPPoEIP:= ValStr;
      end else
      if Check('pppoe.status') then begin
        case ValInt of
          0: ;
          1: ;
        end;
      end else
      if Check('ipaddress') then begin
        FIPAddress:= ValStr;
      end else
      if Check('subnetmask') then begin
        FSubnetMask:= ValStr;
      end else
      if Check('defaultgateway') then begin
        FDefaultGateway:= ValStr;
      end else begin

      end;
    end;
  except
    on e: exception do begin

    end;
  end;
end;

function TGsStatus.LedStatusStr: String;
begin

end;

function TGsStatus.PPPoEStatusStr: String;
begin

end;

function TGsStatus.WiFiStateStr: String;
begin

end;

{ TGsOSD }

constructor TGsOSD.Create(AOwner: TGrandstreamAPI);
begin
  inherited;

end;

destructor TGsOSD.Destroy;
begin

  inherited;
end;

function TGsOSD.Get: TGsRequestResult;
begin

end;

{ TGsMaintenance }

constructor TGsMaintenance.Create(AOwner: TGrandstreamAPI);
begin
  inherited;

end;

destructor TGsMaintenance.Destroy;
begin

  inherited;
end;

function TGsMaintenance.Get: TGsRequestResult;
var
  T: String;
begin
  try
    Result:= inherited Get('maintenance');
    while Items.Count > 0 do begin
      Next;
      if Check('restart') then begin

      end else
      if Check('restore') then begin

      end else
      if Check('update_viatype') then begin
        case ValInt of
          1: FUpdateVia:= guvTFTP;
          2: FUpdateVia:= guvHTTP;
          3: FUpdateVia:= guvHTTPS;
        end;
      end else
      if Check('upgrade.serverpath') then begin
        FUpgradeServerPath:= ValStr;
      end else
      if Check('upgrade.cfgserverpath') then begin
        FUpgradeConfigServerPath:= ValStr;
      end else
      if Check('upgrade_cfg_xml_pwd') then begin
        FUpgradeConfigXmlPassword:= ValStr;
      end else
      if Check('upgrade.automatic') then begin
        FUpgradeAutomatic:= ValBol;
      end else
      if Check('upgrade.interval') then begin
        FUpgradeInterval:= ValInt;
      end else begin

      end;
    end;
  except
    on e: exception do begin

    end;
  end;
end;

procedure TGsMaintenance.Restart;
begin
  //SENSITIVE - MUST PROTECT

end;

procedure TGsMaintenance.Restore;
begin
  //SENSITIVE - MUST PROTECT

end;

{ TGsDevice }

constructor TGsDevice.Create(AOwner: TGrandstreamAPI);
begin
  inherited;
  SetLength(FChannels, 0);
end;

destructor TGsDevice.Destroy;
begin
  ClearChannels;
  inherited;
end;

procedure TGsDevice.ClearChannels;
var
  X: Integer;
begin
  //REDO
end;

function TGsDevice.Count: Integer;
begin
  Result:= Length(FChannels);
end;

function TGsDevice.GetChannel(Index: Integer): PGsDeviceInfo;
begin
  Result:= FChannels[Index];
end;

procedure TGsDevice.SetDeviceName(const Value: String);
begin
  FDeviceName := Value;
end;

function TGsDevice.Get: TGsRequestResult;
var
  I: PGsDeviceInfo;
  X: Integer;
begin
  ClearChannels;
  try
    Result:= inherited Get('device');
    X:= -1;
    while Items.Count > 0 do begin
      Next;
      if Check('devicename') then begin
        FDeviceName:= ValStr;
      end else
      if Check('channel') then begin
        Inc(X);
        SetLength(FChannels, Length(FChannels)+1);
        I:= New(PGsDeviceInfo);
        FChannels[X]:= I;
        I.Channel:= X;
        I.GpioPinMultiplex:= gpmNone;
      end else
      if Check('alarmin.type') then begin
        case ValInt of
          0: I.AlarmInType:= gatNormalOpen;
          1: I.AlarmInType:= gatNormalClose;
        end;
      end else
      if Check('alarmout.type') then begin
        case ValInt of
          0: I.AlarmOutType:= gatNormalOpen;
          1: I.AlarmOutType:= gatNormalClose;
        end;
      end else
      if Check('alarmin.status') then begin
        case ValInt of
          0: I.AlarmInStatus:= gasOpen;
          1: I.AlarmInStatus:= gasClose;
        end;
      end else
      if Check('alarmout.status') then begin
        case ValInt of
          0: I.AlarmOutStatus:= gasOpen;
          1: I.AlarmOutStatus:= gasClose;
        end;
      end else
      if Check('alarm_output_time') then begin
        case ValInt of
          0: I.AlarmOutputTime:= gao0;
          5: I.AlarmOutputTime:= gao5;
          15: I.AlarmOutputTime:= gao15;
          30: I.AlarmOutputTime:= gao30;
          60: I.AlarmOutputTime:= gao60;
          180: I.AlarmOutputTime:= gao180;
          300: I.AlarmOutputTime:= gao300;
          600: I.AlarmOutputTime:= gao600;
          900: I.AlarmOutputTime:= gao900;
          1800: I.AlarmOutputTime:= gao1800;
        end;
      end else
      if Check('gpio_pin_multiplex') then begin
        case ValInt of
          0: I.GpioPinMultiplex:= gpmControl;
          1: I.GpioPinMultiplex:= gpmAlarmIO;
        end;
      end else begin

      end;
    end;
  except
    on e: exception do begin

    end;
  end;
end;

end.