ebe2235117
git-svn-id: https://svn.code.sf.net/p/lazarus-ccr/svn@1834 8e941d3f-bd1b-0410-a28a-d453659cc2b4
1285 lines
45 KiB
ObjectPascal
1285 lines
45 KiB
ObjectPascal
unit android_sdk_bindings_gen;
|
|
|
|
{$mode objfpc}{$H+}
|
|
|
|
interface
|
|
|
|
uses
|
|
Classes, SysUtils;
|
|
|
|
type
|
|
|
|
{ TAndroidSDKBindingsGen }
|
|
|
|
TAndroidSDKBindingsGen = class
|
|
private
|
|
FSourceFile: TStringList;
|
|
FPasOutputTypes, FPasOutputClassesForward, FPasOutputClasses,
|
|
FPasOutputConsts, FPasOutputIDs, FPasOutputImpl, FPasOutputMessages,
|
|
FPasGlobalVars, FPasInitialization: TStringList;
|
|
FJavaOutputIDs, FJavaOutputMethods: TStringList;
|
|
FClassName, FClassNamePas: string; // Class name of the class currently being parsed
|
|
FClassNum, FMethodNum: Integer;
|
|
FIsGlobalObject: Boolean;
|
|
FGlobalObject: string;
|
|
// List of Callback types which are used later
|
|
FCallbackTypesJavaName: TStringList;
|
|
FCallbackTypesParams: TStringList;
|
|
FCallbackTypesInnerName: TStringList;
|
|
FCallbackTypesFirstParam: TStringList;
|
|
//
|
|
// ProcessMethodReturnValue
|
|
FMethodReturnPas, FDeclarationBase: string;
|
|
FDeclarationIsFunction: Boolean;
|
|
// ProcessMethodName
|
|
FMethodName: string;
|
|
// ProcessMethodPreface
|
|
FJavaParamSelf: String;
|
|
FIDString: String;
|
|
FIDSetter, FIDStart, FIDFinished: String;
|
|
FCallbackName, FSetterName, FCallerName: string;
|
|
// ProcessMethodParameters
|
|
FPascalParams, FJavaParams, FFirstParam: string;
|
|
FHasStringParam: Boolean;
|
|
FPasOutputImplCurLine: Integer;
|
|
FCallbackTypePas, FCallbackTypeJava: string;
|
|
//
|
|
procedure GeneratePascalFile(ASourceFile: string; ADest: TStringList);
|
|
procedure GenerateJavaFile(ASourceFile: string; ADest: TStringList);
|
|
procedure ProcessModelFile(ASourceFile, APasOutputFile, AJavaOutputFile: string);
|
|
procedure ProcessModelLine(ASourceLine: string);
|
|
procedure ProcessModelClass(ASourceLine: string; AIsInterface: Boolean);
|
|
procedure ProcessModelMethod(ASourceLine: string; AIsField: Boolean);
|
|
procedure ProcessModelConstructor(ASourceLine: string);
|
|
procedure ProcessModelConst(ASourceLine: string);
|
|
procedure ProcessModelCallbackSetter(ASourceLine: string);
|
|
procedure ProcessModelType(ASourceLine: string);
|
|
//
|
|
procedure ProcessMethodReturnValue(ASourceLine: string; var lReaderPos: Integer);
|
|
procedure ProcessMethodName(ASourceLine: string; var lReaderPos: Integer);
|
|
procedure ProcessMethodPreface(ASourceLine: string; AIsCallback: Boolean);
|
|
procedure ProcessMethodParameters(ASourceLine: string; var lReaderPos: Integer; AAddParamRead: Boolean = True);
|
|
//
|
|
function GetNextWord(ALine: string; var AStartPos: Integer): string;
|
|
function GetPascalTypeName(ABaseName: string): string;
|
|
function PassByReference(ABaseName: string): Boolean;
|
|
function GetJavaResultFunction(AReturnType: string): string;
|
|
function GetJavaTypeReader(AType: string): string;
|
|
function GetJavaTypeLocalVar(AType: string): string;
|
|
function GetJavaTypeConverter(AType: string): string;
|
|
function GetIDString(AMethodName: string): string;
|
|
procedure AddOutputIDs(AIDString: string);
|
|
function ConvertJavaSpecialCharsToUnderline(AStr: string): string;
|
|
function ConvertPointToUnderline(AStr: string): string;
|
|
function JavaRemoveGeneric(AStr: string): string;
|
|
function IsBasicJavaType(AStr: string): Boolean;
|
|
public
|
|
constructor Create;
|
|
destructor Destroy; override;
|
|
procedure GenerateAllBindings(AInputDir, APasOutputDir, AJavaOutputDir: string);
|
|
end;
|
|
|
|
var
|
|
AndroidSDKBindingsGen: TAndroidSDKBindingsGen;
|
|
|
|
implementation
|
|
|
|
{ TAndroidSDKBindingsGen }
|
|
|
|
procedure TAndroidSDKBindingsGen.GeneratePascalFile(ASourceFile: string; ADest: TStringList);
|
|
begin
|
|
ADest.Add(Format('unit %s;', [ChangeFileExt(ExtractFileName(ASourceFile), '')]));
|
|
ADest.Add('');
|
|
ADest.Add('interface');
|
|
ADest.Add('');
|
|
ADest.Add('uses SysUtils, javalang, androidpipescomm;');
|
|
ADest.Add('');
|
|
ADest.Add('{$INTERFACES CORBA}');
|
|
ADest.Add('');
|
|
ADest.Add('type');
|
|
ADest.Add('');
|
|
ADest.Add(' { Forward declaration of classes }');
|
|
ADest.Add('');
|
|
ADest.AddStrings(FPasOutputClassesForward);
|
|
ADest.Add('');
|
|
ADest.Add(' { Types }');
|
|
ADest.Add('');
|
|
ADest.AddStrings(FPasOutputTypes);
|
|
ADest.Add('');
|
|
ADest.Add(' { Classes }');
|
|
ADest.Add('');
|
|
ADest.AddStrings(FPasOutputClasses);
|
|
ADest.Add(' end;');
|
|
ADest.Add('');
|
|
ADest.Add('const');
|
|
ADest.Add(' { Constants }');
|
|
ADest.AddStrings(FPasOutputConsts);
|
|
ADest.Add('');
|
|
ADest.Add('function HandleMessage(AFirstInt: Integer): Boolean;');
|
|
ADest.Add('');
|
|
ADest.Add('var');
|
|
ADest.AddStrings(FPasGlobalVars);
|
|
ADest.Add('');
|
|
ADest.Add('implementation');
|
|
ADest.Add('');
|
|
ADest.Add('const');
|
|
ADest.Add(' { IDs }');
|
|
ADest.Add('');
|
|
ADest.AddStrings(FPasOutputIDs);
|
|
ADest.Add('');
|
|
ADest.Add('{ Implementation of Classes }');
|
|
ADest.Add('');
|
|
ADest.AddStrings(FPasOutputImpl);
|
|
ADest.Add('');
|
|
ADest.Add('{ Message Handling }');
|
|
ADest.Add('');
|
|
ADest.Add('function HandleMessage(AFirstInt: Integer): Boolean;');
|
|
ADest.Add('var');
|
|
ADest.Add(' lInt: Integer;');
|
|
ADest.Add(' lPascalPointer: PtrInt = -1;');
|
|
ADest.Add('begin');
|
|
ADest.Add(' case AFirstInt of');
|
|
ADest.AddStrings(FPasOutputMessages);
|
|
ADest.Add(' end;');
|
|
ADest.Add('end;');
|
|
ADest.Add('');
|
|
ADest.Add('initialization');
|
|
ADest.Add('');
|
|
ADest.AddStrings(FPasInitialization);
|
|
ADest.Add('');
|
|
ADest.Add('end.');
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.GenerateJavaFile(ASourceFile: string; ADest: TStringList);
|
|
begin
|
|
ADest.Add('package com.pascal.androidlcl;');
|
|
ADest.Add('');
|
|
ADest.Add('import android.app.*;');
|
|
ADest.Add('import android.view.*;');
|
|
ADest.Add('import android.os.*;');
|
|
ADest.Add('import android.util.*;');
|
|
ADest.Add('import android.content.*;');
|
|
ADest.Add('import android.view.*;');
|
|
ADest.Add('import android.widget.*;');
|
|
ADest.Add('import android.R.*;');
|
|
ADest.Add('import java.util.*;');
|
|
ADest.Add('import java.lang.*;');
|
|
ADest.Add('');
|
|
ADest.Add('public class AndroidAll');
|
|
ADest.Add('{');
|
|
ADest.Add(' // info from other classes');
|
|
ADest.Add(' Activity activity;');
|
|
ADest.Add(' AndroidPipesComm MyAndroidPipesComm;');
|
|
ADest.Add(' JavaLang MyJavaLang;');
|
|
ADest.Add(' // lists of variables');
|
|
ADest.Add(' ArrayList ViewElements;');
|
|
ADest.Add(' ArrayList ViewElementsTags;');
|
|
ADest.Add('');
|
|
ADest.Add(' public AndroidAll(AndroidPipesComm AAndroidPipesComm, Activity AActivity, JavaLang AJavaLang)');
|
|
ADest.Add(' {');
|
|
ADest.Add(' activity = AActivity;');
|
|
ADest.Add(' MyAndroidPipesComm = AAndroidPipesComm;');
|
|
ADest.Add(' MyJavaLang = AJavaLang;');
|
|
ADest.Add(' ViewElements = new ArrayList();');
|
|
ADest.Add(' ViewElementsTags = new ArrayList();');
|
|
ADest.Add(' }');
|
|
ADest.Add('');
|
|
ADest.Add(' public void DebugOut(String Str)');
|
|
ADest.Add(' {');
|
|
ADest.Add(' MyAndroidPipesComm.DebugOut(Str);');
|
|
ADest.Add(' }');
|
|
ADest.Add('');
|
|
ADest.AddStrings(FJavaOutputIDs);
|
|
ADest.Add('');
|
|
ADest.Add(' public boolean ProcessCommand(int Buffer)');
|
|
ADest.Add(' {');
|
|
ADest.Add(' //DebugOut("AndroidUI.ProcessCommand Command=" + java.lang.Integer.toHexString(Buffer));');
|
|
ADest.Add(' //');
|
|
ADest.Add(' // basic types');
|
|
ADest.Add(' //');
|
|
ADest.Add(' int lInt, lIndex, lPascalPointer;');
|
|
ADest.Add(' boolean lBool;');
|
|
ADest.Add(' float lFloat;');
|
|
ADest.Add(' //');
|
|
ADest.Add(' // Self params');
|
|
ADest.Add(' //');
|
|
ADest.Add(' View param_self_View;');
|
|
ADest.Add(' ViewGroup param_self_ViewGroup;');
|
|
ADest.Add(' TextView param_self_TextView;');
|
|
ADest.Add(' Button param_self_Button;');
|
|
ADest.Add(' EditText param_self_EditText;');
|
|
ADest.Add(' LinearLayout param_self_LinearLayout;');
|
|
ADest.Add(' TimePicker param_self_TimePicker;');
|
|
ADest.Add(' Display param_self_Display;');
|
|
ADest.Add(' DisplayMetrics param_self_DisplayMetrics;');
|
|
ADest.Add(' CompoundButton param_self_CompoundButton;');
|
|
ADest.Add(' WindowManager param_self_WindowManager;');
|
|
ADest.Add(' AbsSpinner param_self_AbsSpinner;');
|
|
ADest.Add(' ArrayAdapter<String> param_self_ArrayAdapter_String_;');
|
|
ADest.Add(' AdapterView param_self_AdapterView;');
|
|
ADest.Add(' AlertDialog.Builder param_self_AlertDialog_Builder;');
|
|
ADest.Add(' Dialog param_self_Dialog;');
|
|
ADest.Add(' AlertDialog param_self_AlertDialog;');
|
|
ADest.Add(' //');
|
|
ADest.Add(' // Params');
|
|
ADest.Add(' //');
|
|
ADest.Add(' ViewGroup.LayoutParams lViewGroup_LayoutParams_1, lViewGroup_LayoutParams_2, lViewGroup_LayoutParams_3;');
|
|
ADest.Add(' SpinnerAdapter lSpinnerAdapter_1;');
|
|
ADest.Add(' DisplayMetrics lDisplayMetrics_1;');
|
|
ADest.Add(' CharSequence lCharSequence_1, lCharSequence_2;');
|
|
ADest.Add(' String lString_1;');
|
|
ADest.Add(' View lView_1;');
|
|
ADest.Add(' int lint_1, lint_2, lint_3, lint_4;');
|
|
ADest.Add(' float lfloat_1, lfloat_2;');
|
|
ADest.Add(' boolean lboolean_1;');
|
|
ADest.Add(' //');
|
|
ADest.Add(' // Results');
|
|
ADest.Add(' //');
|
|
ADest.Add(' float lResult_float;');
|
|
ADest.Add(' int lResult_int;');
|
|
ADest.Add(' boolean lResult_boolean;');
|
|
ADest.Add(' CharSequence lResult_CharSequence;');
|
|
ADest.Add(' Display lResult_Display;');
|
|
ADest.Add(' AlertDialog.Builder lResult_AlertDialog_Builder;');
|
|
ADest.Add(' AlertDialog lResult_AlertDialog;');
|
|
ADest.Add('');
|
|
ADest.Add(' switch (Buffer)');
|
|
ADest.Add(' {');
|
|
ADest.Add('');
|
|
ADest.AddStrings(FJavaOutputMethods);
|
|
ADest.Add('');
|
|
ADest.Add(' default:');
|
|
ADest.Add(' return false;');
|
|
ADest.Add(' }');
|
|
ADest.Add(' return true;');
|
|
ADest.Add(' }');
|
|
ADest.Add('}');
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.ProcessModelFile(ASourceFile, APasOutputFile,
|
|
AJavaOutputFile: string);
|
|
var
|
|
i: Integer;
|
|
lPasOutputFile: TStringList;
|
|
lJavaOutputFile: TStringList;
|
|
begin
|
|
lPasOutputFile := TStringList.Create;
|
|
lJavaOutputFile := TStringList.Create;
|
|
try
|
|
FSourceFile.LoadFromFile(ASourceFile);
|
|
|
|
// Preparations
|
|
FClassName := '';
|
|
|
|
for i := 0 to FSourceFile.Count - 1 do
|
|
begin
|
|
ProcessModelLine(FSourceFile.Strings[i]);
|
|
end;
|
|
|
|
// Now save the Pascal file
|
|
GeneratePascalFile(ASourceFile, lPasOutputFile);
|
|
|
|
lPasOutputFile.SaveToFile(APasOutputFile);
|
|
|
|
GenerateJavaFile(ASourceFile, lJavaOutputFile);
|
|
|
|
lJavaOutputFile.SaveToFile(AJavaOutputFile);
|
|
finally
|
|
lJavaOutputFile.Free;
|
|
lPasOutputFile.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.ProcessModelLine(ASourceLine: string);
|
|
var
|
|
lReaderPos: Integer = 1;
|
|
lCurWord: string;
|
|
begin
|
|
if ASourceLine = '' then Exit;
|
|
|
|
lCurWord := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
// Comments
|
|
if ASourceLine[1] = '#' then Exit;
|
|
|
|
// Starting a new class
|
|
if ASourceLine[1] = '[' then
|
|
begin
|
|
FIsGlobalObject := False;
|
|
ProcessModelClass(ASourceLine, False);
|
|
Exit;
|
|
end;
|
|
|
|
// Starting a new global object class
|
|
if ASourceLine[1] = '%' then
|
|
begin
|
|
FIsGlobalObject := True;
|
|
ProcessModelClass(ASourceLine, False);
|
|
Exit;
|
|
end;
|
|
|
|
// Starting a new interface
|
|
if ASourceLine[1] = '{' then
|
|
begin
|
|
FIsGlobalObject := False;
|
|
ProcessModelClass(ASourceLine, True);
|
|
Exit;
|
|
end;
|
|
|
|
// Adding methods to a class
|
|
if lCurWord = 'method' then
|
|
begin
|
|
ProcessModelMethod(ASourceLine, False);
|
|
Exit;
|
|
end;
|
|
|
|
if lCurWord = 'constructor' then
|
|
begin
|
|
ProcessModelConstructor(ASourceLine);
|
|
Exit;
|
|
end;
|
|
|
|
// Constants
|
|
if lCurWord = 'const' then
|
|
begin
|
|
ProcessModelConst(ASourceLine);
|
|
Exit;
|
|
end;
|
|
|
|
// Callbacks
|
|
if lCurWord = 'callbacksetter' then
|
|
begin
|
|
ProcessModelCallbackSetter(ASourceLine);
|
|
Exit;
|
|
end;
|
|
|
|
// Fields
|
|
if lCurWord = 'field' then
|
|
begin
|
|
ProcessModelMethod(ASourceLine, True);
|
|
Exit;
|
|
end;
|
|
|
|
// Types
|
|
if lCurWord = 'type' then
|
|
begin
|
|
ProcessModelType(ASourceLine);
|
|
Exit;
|
|
end;
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.ProcessModelClass(ASourceLine: string; AIsInterface: Boolean);
|
|
var
|
|
lReaderPos: Integer = 1;
|
|
lCurWord, lParentClassName, lTmpParent: string;
|
|
begin
|
|
if ASourceLine = '' then Exit;
|
|
|
|
lCurWord := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
if FClassName <> '' then
|
|
begin
|
|
FPasOutputClasses.Add(' end;');
|
|
FPasOutputClasses.Add('');
|
|
end;
|
|
|
|
FClassNamePas := GetPascalTypeName(lCurWord);
|
|
FClassName := lCurWord;
|
|
|
|
// Read the global object, if it is one
|
|
if FIsGlobalObject then
|
|
begin
|
|
FGlobalObject := GetNextWord(ASourceLine, lReaderPos);
|
|
FPasGlobalVars.Add(Format(' %s: %s;', [FGlobalObject, FClassNamePas]));
|
|
FPasInitialization.Add(Format(' %s := %s.Create;', [FGlobalObject, FClassNamePas]));
|
|
end;
|
|
|
|
lTmpParent := GetNextWord(ASourceLine, lReaderPos);
|
|
lParentClassName := GetPascalTypeName(lTmpParent);
|
|
|
|
// Read all parents
|
|
while lTmpParent <> '' do
|
|
begin
|
|
lTmpParent := GetNextWord(ASourceLine, lReaderPos);
|
|
if lTmpParent <> '' then
|
|
lParentClassName := lParentClassName + ', ' + GetPascalTypeName(lTmpParent);
|
|
end;
|
|
|
|
// Java classes can implement interfaces, so based on a safe ground
|
|
if lParentClassName = '' then
|
|
if AIsInterface then
|
|
lParentClassName := 'IJavaInterface'
|
|
else
|
|
lParentClassName := 'TJavaObject';
|
|
|
|
if AIsInterface then
|
|
FPasOutputClasses.Add(Format(' %s = interface(%s)', [FClassNamePas, lParentClassName]))
|
|
else
|
|
begin
|
|
FPasOutputClasses.Add(Format(' %s = class(%s)', [FClassNamePas, lParentClassName]));
|
|
FPasOutputClasses.Add(' public');
|
|
end;
|
|
lCurWord := GetNextWord(ASourceLine, lReaderPos);
|
|
Inc(FClassNum);
|
|
FMethodNum := 0;
|
|
|
|
FPasOutputIDs.Add(' // ' + FClassNamePas);
|
|
FJavaOutputIDs.Add(' // ' + FClassName);
|
|
FPasOutputConsts.Add(' { ' + FClassNamePas + ' }');
|
|
if AIsInterface then
|
|
FPasOutputClassesForward.Add(' ' + FClassNamePas + ' = interface;')
|
|
else
|
|
FPasOutputClassesForward.Add(' ' + FClassNamePas + ' = class;')
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.ProcessModelMethod(
|
|
ASourceLine: string; AIsField: Boolean);
|
|
var
|
|
lReaderPos: Integer = 1;
|
|
lParamNum: Integer = 1;
|
|
lCurWord, lParentClassName: string;
|
|
lMethodReturn, lMethodReturnPas, lMethodName, lPasMethodName, lParamType, lParamTypePas, lParamName, lParamPrefix: string;
|
|
lMethodReturnJavaIdentifier: string;
|
|
DeclarationBase, TmpStr, lIDString: string;
|
|
lJavaParamVar, lJavaParams, lJavaParamSelf: string;
|
|
// For adding the var for string params
|
|
HasStringParam: Boolean = False;
|
|
StringParamCount: Integer = 0;
|
|
i: Integer;
|
|
//
|
|
lPascalMethodModifiers: string = '';
|
|
begin
|
|
if ASourceLine = '' then Exit;
|
|
|
|
lCurWord := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
// Method type and name
|
|
lMethodReturn := GetNextWord(ASourceLine, lReaderPos);
|
|
lMethodReturnPas := GetPascalTypeName(lMethodReturn);
|
|
lMethodName := GetNextWord(ASourceLine, lReaderPos);
|
|
if lMethodName = 'create' then lPasMethodName := lMethodName + '_'
|
|
else lPasMethodName := lMethodName;
|
|
|
|
if lMethodReturn = 'void' then DeclarationBase := 'procedure '
|
|
else DeclarationBase := 'function ';
|
|
|
|
// Beginning of the implementation part
|
|
FPasOutputImplCurLine := FPasOutputImpl.Count;
|
|
lIDString := GetIDString(lMethodName);
|
|
|
|
FPasOutputImpl.Add('begin');
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendByte(ShortInt(amkUICommand));');
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendInt(' + lIDString + ');');
|
|
if not FIsGlobalObject then
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendInt(Index); // Self, Java Pointer');
|
|
|
|
lJavaParamSelf := 'param_self_' + JavaRemoveGeneric(ConvertPointToUnderline(FClassName));
|
|
FJavaOutputMethods.Add(' // ' + ASourceLine);
|
|
FJavaOutputMethods.Add(' case ' + lIDString + ':');
|
|
FJavaOutputMethods.Add(' DebugOut("' + lIDString + '");');
|
|
if not FIsGlobalObject then
|
|
begin
|
|
FJavaOutputMethods.Add(' // Self');
|
|
FJavaOutputMethods.Add(' lInt = MyAndroidPipesComm.GetInt();');
|
|
FJavaOutputMethods.Add(' ' + lJavaParamSelf + ' = (' + FClassName + ') ViewElements.get(lInt);');
|
|
end
|
|
else
|
|
lJavaParamSelf := FGlobalObject;
|
|
FJavaOutputMethods.Add(' // params');
|
|
|
|
// Lists of constants for the IDs
|
|
AddOutputIDs(lIDString);
|
|
|
|
// Add all parameters
|
|
TmpStr := lPasMethodName + '(';
|
|
|
|
repeat
|
|
lParamType := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
// Method modifiers
|
|
if (lParamType = 'virtual') or (lParamType = 'override')
|
|
or (lParamType = 'overload') then
|
|
begin
|
|
lPascalMethodModifiers := Format(' %s;', [lParamType]);
|
|
Continue;
|
|
end;
|
|
|
|
lParamTypePas := GetPascalTypeName(lParamType);
|
|
lParamName := GetNextWord(ASourceLine, lReaderPos);
|
|
if PassByReference(lParamType) then lParamPrefix := 'var '
|
|
else lParamPrefix := '';
|
|
|
|
if lParamName = '' then Break;
|
|
|
|
TmpStr := TmpStr + lParamPrefix + lParamName + ': ' + lParamTypePas + '; ';
|
|
|
|
// Pascal parameter sending
|
|
if lParamTypePas = 'string' then
|
|
begin
|
|
HasStringParam := True;
|
|
Inc(StringParamCount);
|
|
FPasOutputImpl.Insert(FPasOutputImplCurLine+1, Format(' lString_%d := TString.Create(%s);', [StringParamCount, lParamName]));
|
|
FPasOutputImpl.Add(Format(' vAndroidPipesComm.SendInt(lString_%d.Index); // text', [StringParamCount]));
|
|
end
|
|
else if IsBasicJavaType(lParamType) then
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendInt(Integer(' + lParamName + '));')
|
|
else // for objects
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendInt(Integer(' + lParamName + '.Index));');
|
|
|
|
// Java parameter reading
|
|
lJavaParamVar := Format('l%s_%d', [ConvertPointToUnderline(lParamType), lParamNum]);
|
|
FJavaOutputMethods.Add(Format(' %s = MyAndroidPipesComm.%s();',
|
|
[GetJavaTypeLocalVar(lParamType), GetJavaTypeReader(lParamType)]));
|
|
FJavaOutputMethods.Add(Format(' %s = %s;',
|
|
[lJavaParamVar, GetJavaTypeConverter(lParamType)]));
|
|
lJavaParams := lJavaParams + lJavaParamVar + ', ';
|
|
|
|
Inc(lParamNum);
|
|
until lParamName = '';
|
|
|
|
// Remove the last ; for the parameters, if necessary
|
|
if (Length(TmpStr) > 0) and (TmpStr[Length(TmpStr)-1] = ';') then
|
|
TmpStr := System.Copy(TmpStr, 0, Length(TmpStr)-2);
|
|
// And for Java params too
|
|
lJavaParams := System.Copy(lJavaParams, 0, Length(lJavaParams)-2);
|
|
|
|
// Add the Pascal return
|
|
if lMethodReturn = 'void' then
|
|
begin
|
|
TmpStr := TmpStr + ');';
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.WaitForReturn();');
|
|
end
|
|
else if (lMethodReturn = 'CharSequence') or (lMethodReturn = 'String') then
|
|
begin
|
|
TmpStr := TmpStr + '): ' + lMethodReturnPas + ';';
|
|
FPasOutputImpl.Add(' Result := vAndroidPipesComm.WaitForStringReturn();');
|
|
end
|
|
else if not IsBasicJavaType(lMethodReturn) then
|
|
begin
|
|
TmpStr := TmpStr + '): ' + lMethodReturnPas + ';';
|
|
FPasOutputImpl.Add(' Result := ' + lMethodReturnPas + '.Create(vAndroidPipesComm.WaitForIntReturn());');
|
|
end
|
|
else
|
|
begin
|
|
TmpStr := TmpStr + '): ' + lMethodReturnPas + ';';
|
|
FPasOutputImpl.Add(' Result := ' + lMethodReturnPas + '(vAndroidPipesComm.WaitForIntReturn());');
|
|
end;
|
|
|
|
// Insert the start
|
|
FPasOutputClasses.Add(' ' + DeclarationBase + TmpStr + lPascalMethodModifiers);
|
|
FPasOutputImpl.Insert(FPasOutputImplCurLine, DeclarationBase + FClassNamePas + '.' + TmpStr);
|
|
if HasStringParam then
|
|
begin
|
|
FPasOutputImpl.Insert(FPasOutputImplCurLine+1, 'var');
|
|
for i := 1 to StringParamCount do
|
|
begin
|
|
FPasOutputImpl.Insert(FPasOutputImplCurLine+1+i, Format(' lString_%d: TString;', [i]));
|
|
FPasOutputImpl.Add(Format(' lString_%d.Free;', [i]));
|
|
end;
|
|
end;
|
|
FPasOutputImpl.Add('end;');
|
|
FPasOutputImpl.Add('');
|
|
|
|
// Java Return
|
|
FJavaOutputMethods.Add(' //');
|
|
lMethodReturnJavaIdentifier := 'lResult_' + ConvertPointToUnderline(lMethodReturn);
|
|
if AIsField then
|
|
begin
|
|
FJavaOutputMethods.Add(Format(' %s = %s.%s;', [lMethodReturnJavaIdentifier, lJavaParamSelf, lMethodName]));
|
|
FJavaOutputMethods.Add(Format(' MyAndroidPipesComm.%s(%s);', [GetJavaResultFunction(lMethodReturn), lMethodReturnJavaIdentifier]));
|
|
end
|
|
else if lMethodReturn = 'void' then
|
|
begin
|
|
FJavaOutputMethods.Add(Format(' %s.%s(%s);', [lJavaParamSelf, lMethodName, lJavaParams]));
|
|
FJavaOutputMethods.Add(Format(' MyAndroidPipesComm.SendResult();', []));
|
|
end
|
|
else
|
|
begin
|
|
FJavaOutputMethods.Add(Format(' %s = %s.%s(%s);', [lMethodReturnJavaIdentifier, lJavaParamSelf, lMethodName, lJavaParams]));
|
|
if IsBasicJavaType(lMethodReturn) or (lMethodReturn = 'CharSequence') or (lMethodReturn = 'String') then
|
|
FJavaOutputMethods.Add(Format(' MyAndroidPipesComm.%s(%s);', [GetJavaResultFunction(lMethodReturn), lMethodReturnJavaIdentifier]))
|
|
else
|
|
begin
|
|
FJavaOutputMethods.Add(Format(' ViewElements.add(%s);', [lMethodReturnJavaIdentifier]));
|
|
FJavaOutputMethods.Add( ' ViewElementsTags.add(null);');
|
|
FJavaOutputMethods.Add(Format(' MyAndroidPipesComm.%s(ViewElements.size() - 1);', [GetJavaResultFunction(lMethodReturn)]))
|
|
end;
|
|
end;
|
|
FJavaOutputMethods.Add(' break;');
|
|
|
|
Inc(FMethodNum);
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.ProcessModelConstructor(ASourceLine: string);
|
|
var
|
|
lReaderPos: Integer = 1;
|
|
lCurWord: string;
|
|
lParamNum: Integer = 1;
|
|
lMethodName, lParamType, lParamTypePas, lParamName: string;
|
|
lConstructorPasParams, lConstructorJavaParams, lParamPrefix, lJavaParamVar: string;
|
|
DeclarationBase, lIDString: string;
|
|
HasActivityParam: Boolean = False;
|
|
lPascalMethodModifiers: String = '';
|
|
begin
|
|
if ASourceLine = '' then Exit;
|
|
|
|
lCurWord := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
// Method type and name
|
|
lMethodName := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
lIDString := GetIDString(lMethodName);
|
|
|
|
AddOutputIDs(lIDString);
|
|
|
|
FPasOutputImplCurLine := FPasOutputImpl.Count;
|
|
FPasOutputImpl.Add('begin');
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendByte(ShortInt(amkUICommand));');
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendInt(' + lIDString + ');');
|
|
|
|
FJavaOutputMethods.Add(' case ' + lIDString + ':');
|
|
FJavaOutputMethods.Add(' DebugOut("' + lIDString + '");');
|
|
|
|
// Constructor parameters
|
|
lConstructorJavaParams := '';
|
|
lConstructorPasParams := '';
|
|
|
|
repeat
|
|
lParamType := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
// Method modifiers
|
|
if (lParamType = 'virtual') or (lParamType = 'override') then
|
|
begin
|
|
lPascalMethodModifiers := Format(' %s;', [lParamType]);
|
|
Continue;
|
|
end;
|
|
|
|
// The Activity global object doesn't appear in the Pascal side and
|
|
//comes as a single word in the txt file
|
|
if (lParamType = 'Activity') then
|
|
begin
|
|
HasActivityParam := True;
|
|
lParamName := 'ReturnToRepeat';
|
|
Continue;
|
|
end;
|
|
|
|
lParamTypePas := GetPascalTypeName(lParamType);
|
|
lParamName := GetNextWord(ASourceLine, lReaderPos);
|
|
if PassByReference(lParamType) then lParamPrefix := 'var '
|
|
else lParamPrefix := '';
|
|
|
|
if lParamName = '' then Break;
|
|
|
|
lConstructorPasParams := lConstructorPasParams + lParamPrefix + lParamName + ': ' + lParamTypePas + '; ';
|
|
|
|
// Pascal parameter sending
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendInt(Integer(' + lParamName + '));');
|
|
|
|
// Java parameter reading
|
|
lJavaParamVar := 'l' + lParamType + '_' + IntToStr(lParamNum);
|
|
FJavaOutputMethods.Add(' ' + lJavaParamVar + ' = MyAndroidPipesComm.' + GetJavaTypeReader(lParamType) + '();');
|
|
lConstructorJavaParams := lConstructorJavaParams + lJavaParamVar + ', ';
|
|
|
|
Inc(lParamNum);
|
|
until lParamName = '';
|
|
|
|
if HasActivityParam then lConstructorJavaParams := 'activity, ' + lConstructorJavaParams;
|
|
|
|
// Remove the last ; for the parameters, if necessary
|
|
if (Length(lConstructorPasParams) > 0) and (lConstructorPasParams[Length(lConstructorPasParams)-1] = ';') then
|
|
lConstructorPasParams := System.Copy(lConstructorPasParams, 0, Length(lConstructorPasParams)-2);
|
|
// And for Java params too
|
|
lConstructorJavaParams := System.Copy(lConstructorJavaParams, 0, Length(lConstructorJavaParams)-2);
|
|
|
|
// Finalization of the constructor
|
|
|
|
FPasOutputClasses.Add(Format(' constructor %s(%s);%s', [lMethodName, lConstructorPasParams, lPascalMethodModifiers]));
|
|
//
|
|
FPasOutputImpl.Insert(FPasOutputImplCurLine,
|
|
Format('constructor %s.%s(%s);', [FClassNamePas, lMethodName, lConstructorPasParams]));
|
|
FPasOutputImpl.Add(' Index := vAndroidPipesComm.WaitForIntReturn();');
|
|
FPasOutputImpl.Add('end;');
|
|
|
|
FJavaOutputMethods.Add(' ViewElements.add(new ' + FClassName + '(' + lConstructorJavaParams + '));');
|
|
FJavaOutputMethods.Add(' ViewElementsTags.add(null);');
|
|
FJavaOutputMethods.Add(' MyAndroidPipesComm.SendIntResult(ViewElements.size() - 1);');
|
|
FJavaOutputMethods.Add(' break;');
|
|
|
|
Inc(FMethodNum);
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.ProcessModelConst(ASourceLine: string);
|
|
var
|
|
lReaderPos: Integer = 1;
|
|
lCurWord: string;
|
|
lConstName, lConstValue: string;
|
|
begin
|
|
if ASourceLine = '' then Exit;
|
|
|
|
lConstName := GetNextWord(ASourceLine, lReaderPos);
|
|
lConstName := GetNextWord(ASourceLine, lReaderPos);
|
|
lConstValue := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
// Method type and name
|
|
FPasOutputConsts.Add(Format(' %s = %s;', [lConstName, lConstValue]));
|
|
end;
|
|
|
|
// old declaration: callbacksettercaller setOnClickListener callOnClickListener OnClickCallback = procedure (v: TView) of object;
|
|
// new declaration: callbacksetter void setOnClickListener($View.OnClickListener l)
|
|
procedure TAndroidSDKBindingsGen.ProcessModelCallbackSetter(ASourceLine: string);
|
|
var
|
|
lReaderPos: Integer = 1;
|
|
lCurWord: string;
|
|
lStr: String;
|
|
lSeparator: String;
|
|
lJavaCallbackIndex: Integer;
|
|
lJavaCallbackParams, lJavaCallbackInnerName, lFirstCallbackParam: String;
|
|
lHugeParamList: TStringList;
|
|
lHugeParamListText: String;
|
|
begin
|
|
if ASourceLine = '' then Exit;
|
|
|
|
lStr := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
ProcessMethodReturnValue(ASourceLine, lReaderPos);
|
|
ProcessMethodName(ASourceLine, lReaderPos);
|
|
|
|
// Pascal and Java Implementation Start
|
|
ProcessMethodPreface(ASourceLine, True);
|
|
|
|
ProcessMethodParameters(ASourceLine, lReaderPos);
|
|
|
|
// Pascal implementation continuation
|
|
if FPascalParams = '' then lSeparator := ''
|
|
else lSeparator := '; ';
|
|
FPasOutputImpl.Insert(FPasOutputImplCurLine,
|
|
Format('procedure %s.%s(%s%sACallback: %s);', [FClassNamePas, FSetterName, FPascalParams, lSeparator, FCallbackTypePas]));
|
|
|
|
FPasOutputImpl.Add( ' vAndroidPipesComm.WaitForReturn();');
|
|
FPasOutputImpl.Add( 'end;');
|
|
FPasOutputImpl.Add( '');
|
|
FPasOutputImpl.Add(Format('procedure %s.%s();', [FClassNamePas, FCallerName]));
|
|
FPasOutputImpl.Add( 'begin');
|
|
FPasOutputImpl.Add(Format(' if Assigned(%s) then %s();', [FCallbackName, FCallbackName]));
|
|
FPasOutputImpl.Add( 'end;');
|
|
|
|
// Pascal Interface
|
|
FPasOutputClasses.Add( ' public');
|
|
FPasOutputClasses.Add(Format(' %s: %s;', [FCallbackName, FCallbackTypePas]));
|
|
FPasOutputClasses.Add(Format(' procedure %s(%s%sACallback: %s);', [FSetterName, FPascalParams, lSeparator, FCallbackTypePas]));
|
|
FPasOutputClasses.Add(Format(' procedure %s();', [FCallerName]));
|
|
FPasOutputClasses.Add( ' public');
|
|
|
|
// Pascal Message Reader
|
|
FPasOutputMessages.Add( ' ' + FIDStart + ':');
|
|
FPasOutputMessages.Add( ' begin');
|
|
FPasOutputMessages.Add( ' lPascalPointer := vAndroidPipesComm.ReadInt();');
|
|
FPasOutputMessages.Add(Format(' %s(lPascalPointer).%s();', [FClassNamePas, FCallerName]));
|
|
FPasOutputMessages.Add( ' vAndroidPipesComm.SendMessage(amkUICommand, ' + FIDFinished + ');');
|
|
FPasOutputMessages.Add( ' end;');
|
|
{ amkUI_MenuItem_setOnMenuItemClickListener_Start:
|
|
begin
|
|
lInt := ReadInt();
|
|
lMenuItem := TMenuItem(FindItemIdInList(MenuItems, lInt));
|
|
if lMenuItem <> nil then
|
|
lInt := lMenuItem.callOnMenuItemClickListener();
|
|
vAndroidPipesComm.SendMessage(amkUICommand, amkUI_MenuItem_setOnMenuItemClickListener_Finished);
|
|
vAndroidPipesComm.SendInt(lInt);
|
|
end;
|
|
end;}
|
|
|
|
// -----------------------------------------------
|
|
// Now Java:
|
|
// -----------------------------------------------
|
|
|
|
lJavaCallbackIndex := FCallbackTypesJavaName.IndexOf(FCallbackTypeJava);
|
|
lJavaCallbackParams := FCallbackTypesParams.Strings[lJavaCallbackIndex];
|
|
lJavaCallbackInnerName := FCallbackTypesInnerName.Strings[lJavaCallbackIndex];
|
|
lFirstCallbackParam := FCallbackTypesFirstParam.Strings[lJavaCallbackIndex];
|
|
|
|
lHugeParamList := TStringList.Create;
|
|
lHugeParamList.Add(Format(' new %s()', [FCallbackTypeJava]));
|
|
lHugeParamList.Add( ' {');
|
|
lHugeParamList.Add(Format(' public void %s(%s)', [lJavaCallbackInnerName, lJavaCallbackParams]));
|
|
lHugeParamList.Add( ' {');
|
|
lHugeParamList.Add( ' // Perform action');
|
|
lHugeParamList.Add(Format(' DebugOut("START %s");', [FCallbackTypeJava]));
|
|
lHugeParamList.Add(Format(' MyAndroidPipesComm.SendMessage(AndroidPipesComm.amkUICommand, %s);', [FIDStart]));
|
|
lHugeParamList.Add(Format(' Integer lTag = (Integer) ViewElementsTags.get(ViewElements.indexOf(%s));', [lFirstCallbackParam]));
|
|
//FJavaOutputMethods.Add( ' Integer lTag = (Integer) v.getTag();');
|
|
lHugeParamList.Add( ' MyAndroidPipesComm.SendInt(lTag.intValue());');
|
|
lHugeParamList.Add(Format(' MyAndroidPipesComm.WaitForPascalMessage(AndroidPipesComm.amkUICommand, %s);', [FIDFinished]));
|
|
lHugeParamList.Add(Format(' DebugOut("END %s");', [FCallbackTypeJava]));
|
|
lHugeParamList.Add( ' }');
|
|
lHugeParamList.Add( ' }');
|
|
lHugeParamListText := StringReplace(FJavaParams, '$', lHugeParamList.Text, []);
|
|
lHugeParamList.Free;
|
|
|
|
FJavaOutputMethods.Add( ' // Run the code');
|
|
FJavaOutputMethods.Add(Format(' %s.%s(%s);', [FJavaParamSelf, FMethodName, lHugeParamListText]));
|
|
FJavaOutputMethods.Add( ' MyAndroidPipesComm.SendResult();');
|
|
FJavaOutputMethods.Add( ' break;');
|
|
(* case amkUI_TextView_setOnClickListener:
|
|
DebugOut("amkUI_TextView_setOnClickListener");
|
|
// Get Self
|
|
lInt = MyAndroidPipesComm.GetInt();
|
|
lTextView = (TextView) ViewElements.get(lInt);
|
|
lPascalPointer = MyAndroidPipesComm.GetInt();
|
|
lTextView.setTag(Integer.valueOf(lPascalPointer));
|
|
|
|
// Run the code
|
|
lTextView.setOnClickListener(
|
|
new View.OnClickListener()
|
|
{
|
|
public void onClick(View v)
|
|
{
|
|
// Perform action on click
|
|
DebugOut("START TextView OnClickListener");
|
|
MyAndroidPipesComm.SendMessage(AndroidPipesComm.amkUICommand, amkUI_TextView_OnClickCallback_Start);
|
|
//lIndex := UIElements.indexOf(v);
|
|
//MyAndroidPipesComm.SendInt(lIndex);
|
|
Integer lTag = (Integer) v.getTag();
|
|
MyAndroidPipesComm.SendInt(lTag.intValue());
|
|
MyAndroidPipesComm.WaitForPascalMessage(AndroidPipesComm.amkUICommand, amkUI_TextView_OnClickCallback_Finished);
|
|
DebugOut("END TextView OnClickListener");
|
|
}
|
|
});
|
|
MyAndroidPipesComm.SendResult();
|
|
break;*)
|
|
end;
|
|
|
|
// type View.OnClickListener = void onClick(View v)
|
|
procedure TAndroidSDKBindingsGen.ProcessModelType(ASourceLine: string);
|
|
var
|
|
lReaderPos: Integer = 1;
|
|
lCurWord: string;
|
|
lStr, lCallbackDeclaration, lPascalType: String;
|
|
lJavaName, lJavaParams, lFirstParam: String;
|
|
begin
|
|
if ASourceLine = '' then Exit;
|
|
|
|
lStr := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
lStr := GetNextWord(ASourceLine, lReaderPos);
|
|
lJavaName := lStr;
|
|
lPascalType := GetPascalTypeName(lStr);
|
|
|
|
ProcessMethodReturnValue(ASourceLine, lReaderPos);
|
|
ProcessMethodName(ASourceLine, lReaderPos);
|
|
lJavaParams := Copy(ASourceLine, lReaderPos, Length(ASourceLine));
|
|
lJavaParams := Trim(lJavaParams);
|
|
lJavaParams := Copy(lJavaParams, 2, Length(lJavaParams)-2);
|
|
|
|
ProcessMethodParameters(ASourceLine, lReaderPos, False);
|
|
|
|
// Correct code, but at the moment too complex
|
|
|
|
{$IFDEF CORRECT_TYPES}
|
|
if FDeclarationIsFunction then
|
|
FPasOutputTypes.Add(Format(' %s = %s (%s): %s of object;', [lPascalType, FDeclarationBase, FPascalParams, FMethodReturnPas]))
|
|
else
|
|
FPasOutputTypes.Add(Format(' %s = %s (%s) of object;', [lPascalType, FDeclarationBase, FPascalParams]));
|
|
{$ELSE}
|
|
FPasOutputTypes.Add(Format(' %s = procedure () of object;', [lPascalType, FDeclarationBase, FPascalParams]));
|
|
{$ENDIF}
|
|
|
|
// Also add to the lists
|
|
FCallbackTypesJavaName.Add(lJavaName);
|
|
FCallbackTypesParams.Add(lJavaParams);
|
|
FCallbackTypesInnerName.Add(FMethodName);
|
|
FCallbackTypesFirstParam.Add(FFirstParam);
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.ProcessMethodReturnValue(ASourceLine: string;
|
|
var lReaderPos: Integer);
|
|
var
|
|
lMethodReturn: String;
|
|
begin
|
|
// Method type and name
|
|
lMethodReturn := GetNextWord(ASourceLine, lReaderPos);
|
|
FMethodReturnPas := GetPascalTypeName(lMethodReturn);
|
|
|
|
if lMethodReturn = 'void' then
|
|
begin
|
|
FDeclarationBase := 'procedure';
|
|
FDeclarationIsFunction := False;
|
|
end
|
|
else
|
|
begin
|
|
FDeclarationBase := 'function';
|
|
FDeclarationIsFunction := True;
|
|
end;
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.ProcessMethodName(ASourceLine: string;
|
|
var lReaderPos: Integer);
|
|
begin
|
|
FMethodName := GetNextWord(ASourceLine, lReaderPos);
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.ProcessMethodPreface(ASourceLine: string; AIsCallback: Boolean);
|
|
begin
|
|
FIDString := GetIDString(FMethodName);
|
|
// Lists of constants for the IDs
|
|
|
|
if not AIsCallback then AddOutputIDs(FIDString)
|
|
else
|
|
begin
|
|
FSetterName := FMethodName;
|
|
FIDSetter := GetIDString(FSetterName);
|
|
FCallbackName := Copy(FSetterName, 4, Length(FSetterName)); // remove the "set" from the setter name
|
|
FCallerName := 'call' + FCallbackName;
|
|
AddOutputIDs(FIDSetter);
|
|
Inc(FMethodNum);
|
|
FIDStart := GetIDString(FCallbackName + '_Start');
|
|
AddOutputIDs(FIDStart);
|
|
Inc(FMethodNum);
|
|
FIDFinished := GetIDString(FCallbackName + '_Finished');
|
|
AddOutputIDs(FIDFinished);
|
|
Inc(FMethodNum);
|
|
end;
|
|
|
|
// Pascal implementation start, without method title
|
|
FPasOutputImplCurLine := FPasOutputImpl.Count;
|
|
FPasOutputImpl.Add( 'begin');
|
|
if AIsCallback then
|
|
FPasOutputImpl.Add(Format(' %s := ACallback;', [FCallbackName]));
|
|
FPasOutputImpl.Add( ' vAndroidPipesComm.SendByte(ShortInt(amkUICommand));');
|
|
FPasOutputImpl.Add( ' vAndroidPipesComm.SendInt(' + FIDSetter + ');');
|
|
if not FIsGlobalObject then
|
|
FPasOutputImpl.Add( ' vAndroidPipesComm.SendInt(Index); // Self, Java Index');
|
|
if AIsCallback then
|
|
FPasOutputImpl.Add( ' vAndroidPipesComm.SendInt(PtrInt(Self)); // Self, Pascal pointer');
|
|
|
|
// Java implementation
|
|
FJavaParamSelf := 'param_self_' + JavaRemoveGeneric(ConvertPointToUnderline(FClassName));
|
|
FJavaOutputMethods.Add(Format(' // %s', [ASourceLine]));
|
|
FJavaOutputMethods.Add(Format(' case %s:', [FIDString]));
|
|
FJavaOutputMethods.Add(Format(' DebugOut("%s");', [FIDString]));
|
|
if not FIsGlobalObject then
|
|
begin
|
|
FJavaOutputMethods.Add( ' // Self');
|
|
FJavaOutputMethods.Add( ' lInt = MyAndroidPipesComm.GetInt();');
|
|
FJavaOutputMethods.Add(Format(' %s = (%s) ViewElements.get(lInt);', [FJavaParamSelf, FClassName]));
|
|
end
|
|
else
|
|
FJavaParamSelf := FGlobalObject;
|
|
|
|
FJavaOutputMethods.Add(' // params');
|
|
|
|
if AIsCallback then
|
|
begin
|
|
FJavaOutputMethods.Add( ' lPascalPointer = MyAndroidPipesComm.GetInt();');
|
|
FJavaOutputMethods.Add(Format(' ViewElementsTags.set(lInt, new Integer(lPascalPointer));', [fJavaParamSelf]));
|
|
//FJavaOutputMethods.Add(Format(' %s.setTag(Integer.valueOf(lPascalPointer));', [lJavaParamSelf]));
|
|
FJavaOutputMethods.Add( '');
|
|
end;
|
|
end;
|
|
|
|
// callbacksetter void setOnClickListener($View.OnClickListener l)
|
|
// $ indicates that this parameter should be skipped
|
|
procedure TAndroidSDKBindingsGen.ProcessMethodParameters(ASourceLine: string;
|
|
var lReaderPos: Integer; AAddParamRead: Boolean);
|
|
var
|
|
lParamNum: Integer = 1;
|
|
TmpStr: String;
|
|
lParamType, lPascalMethodModifiers: String;
|
|
lParamTypePas, lParamName, lParamPrefix: String;
|
|
lJavaParams, lJavaParamVar: String;
|
|
StringParamCount: Integer = 0;
|
|
i: Integer;
|
|
begin
|
|
// Add all parameters
|
|
TmpStr := '';
|
|
lJavaParams := '';
|
|
FHasStringParam := False;
|
|
FCallbackTypePas := '';
|
|
FFirstParam := '';
|
|
|
|
repeat
|
|
lParamType := GetNextWord(ASourceLine, lReaderPos);
|
|
|
|
if lParamType = '' then Break;
|
|
|
|
// Method modifiers
|
|
if (lParamType = 'virtual') or (lParamType = 'override') then Continue;
|
|
if (lParamType = 'overload') then
|
|
begin
|
|
lPascalMethodModifiers := ' overload;';
|
|
Continue;
|
|
end;
|
|
|
|
// Parameter to skip because it is a callback name, just write "$, " to the Java Params
|
|
if lParamType[1] = '$' then
|
|
begin
|
|
lJavaParams := lJavaParams + '$, ';
|
|
FCallbackTypeJava := StringReplace(lParamType, '$', '', [rfReplaceAll]);
|
|
FCallbackTypePas := GetPascalTypeName(lParamType);
|
|
FCallbackTypePas := StringReplace(FCallbackTypePas, '$', '', [rfReplaceAll]);
|
|
lParamType := GetNextWord(ASourceLine, lReaderPos);
|
|
Continue;
|
|
end;
|
|
|
|
lParamTypePas := GetPascalTypeName(lParamType);
|
|
lParamName := GetNextWord(ASourceLine, lReaderPos);
|
|
if FFirstParam = '' then FFirstParam := lParamName;
|
|
if PassByReference(lParamType) then lParamPrefix := 'var '
|
|
else lParamPrefix := '';
|
|
|
|
if lParamName = '' then Break;
|
|
|
|
TmpStr := TmpStr + lParamPrefix + lParamName + ': ' + lParamTypePas + '; ';
|
|
|
|
if AAddParamRead then
|
|
begin
|
|
// Pascal parameter sending
|
|
if lParamTypePas = 'string' then
|
|
begin
|
|
FHasStringParam := True;
|
|
Inc(StringParamCount);
|
|
FPasOutputImpl.Insert(FPasOutputImplCurLine+1, Format(' lString_%d := TString.Create(%s);', [StringParamCount, lParamName]));
|
|
FPasOutputImpl.Add(Format(' vAndroidPipesComm.SendInt(lString_%d.Index); // text', [StringParamCount]));
|
|
end
|
|
else if IsBasicJavaType(lParamType) then
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendInt(Integer(' + lParamName + '));')
|
|
else // for objects
|
|
FPasOutputImpl.Add(' vAndroidPipesComm.SendInt(Integer(' + lParamName + '.Index));');
|
|
|
|
// Java parameter reading
|
|
lJavaParamVar := Format('l%s_%d', [ConvertPointToUnderline(lParamType), lParamNum]);
|
|
FJavaOutputMethods.Add(Format(' %s = MyAndroidPipesComm.%s();',
|
|
[GetJavaTypeLocalVar(lParamType), GetJavaTypeReader(lParamType)]));
|
|
FJavaOutputMethods.Add(Format(' %s = %s;',
|
|
[lJavaParamVar, GetJavaTypeConverter(lParamType)]));
|
|
lJavaParams := lJavaParams + lJavaParamVar + ', ';
|
|
|
|
Inc(lParamNum);
|
|
end;
|
|
until lParamName = '';
|
|
|
|
// Remove the last ; for the parameters, if necessary
|
|
if (Length(TmpStr) > 0) and (TmpStr[Length(TmpStr)-1] = ';') then
|
|
TmpStr := System.Copy(TmpStr, 0, Length(TmpStr)-2);
|
|
FPascalParams := TmpStr;
|
|
// And for Java params too
|
|
FJavaParams := System.Copy(lJavaParams, 0, Length(lJavaParams)-2);
|
|
|
|
// Insert the start
|
|
//FPasOutputClasses.Add(' ' + DeclarationBase + TmpStr + lPascalMethodModifiers);
|
|
//FPasOutputImpl.Insert(FPasOutputImplCurLine, DeclarationBase + FClassNamePas + '.' + TmpStr);
|
|
if FHasStringParam then
|
|
begin
|
|
FPasOutputImpl.Insert(FPasOutputImplCurLine, 'var');
|
|
for i := 1 to StringParamCount do
|
|
begin
|
|
FPasOutputImpl.Insert(FPasOutputImplCurLine+i, Format(' lString_%d: TString;', [i]));
|
|
FPasOutputImpl.Add(Format(' lString_%d.Free;', [i]));
|
|
end;
|
|
end;
|
|
//FPasOutputImpl.Add('end;');
|
|
//FPasOutputImpl.Add('');
|
|
end;
|
|
|
|
{ Reads one word in a string, starting at AStartPos (1-based index)
|
|
and going up to a space or comma or ( or ) or another separator }
|
|
function TAndroidSDKBindingsGen.GetNextWord(ALine: string;
|
|
var AStartPos: Integer): string;
|
|
const
|
|
WordSeparators = [' ','(',')','[',']','{','}','%',',',';',':','=',#9{TAB}];
|
|
var
|
|
lState: Integer = 0;
|
|
begin
|
|
Result := '';
|
|
|
|
while AStartPos <= Length(ALine) do
|
|
begin
|
|
// Searching the word start
|
|
if lState = 0 then
|
|
begin
|
|
if ALine[AStartPos] in WordSeparators then Inc(AStartPos)
|
|
else
|
|
begin
|
|
Result := ALine[AStartPos];
|
|
Inc(AStartPos);
|
|
lState := 1;
|
|
end;
|
|
end
|
|
// Reading until the word finishes
|
|
else
|
|
begin
|
|
if ALine[AStartPos] in WordSeparators then Exit
|
|
else
|
|
begin
|
|
Result := Result + ALine[AStartPos];
|
|
Inc(AStartPos);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.GetPascalTypeName(ABaseName: string): string;
|
|
begin
|
|
if ABaseName = '' then Exit('');
|
|
|
|
if ABaseName = 'int' then Result := 'Integer'
|
|
else if ABaseName = 'boolean' then Result := 'Boolean'
|
|
else if ABaseName = 'float' then Result := 'Single'
|
|
else if ABaseName = 'void' then Result := ABaseName
|
|
else if (ABaseName = 'CharSequence') or (ABaseName = 'String') then Result := 'string'
|
|
else if ABaseName = 'TJavaObject' then Result := ABaseName
|
|
else
|
|
begin
|
|
Result := 'T' + ABaseName;
|
|
Result := ConvertJavaSpecialCharsToUnderline(Result);
|
|
end;
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.PassByReference(ABaseName: string): Boolean;
|
|
begin
|
|
if ABaseName = '' then Exit(False);
|
|
|
|
if ABaseName = 'int' then Result := False
|
|
else if ABaseName = 'boolean' then Result := False
|
|
else if ABaseName = 'float' then Result := False
|
|
// else if (ABaseName = 'CharSequence') or (ABaseName = 'String') then Result := False
|
|
else Result := False;
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.GetJavaResultFunction(AReturnType: string
|
|
): string;
|
|
begin
|
|
if AReturnType = 'boolean' then Result := 'SendBoolResult'
|
|
else if AReturnType = 'float' then Result := 'SendFloatResult'
|
|
else if (AReturnType = 'CharSequence') or (AReturnType = 'String') then Result := 'SendStringResult'
|
|
else Result := 'SendIntResult';
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.GetJavaTypeReader(AType: string): string;
|
|
begin
|
|
if AType = 'boolean' then Exit('GetBool')
|
|
else if AType = 'float' then Exit('GetFloat')
|
|
else Exit('GetInt');
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.GetJavaTypeLocalVar(AType: string): string;
|
|
begin
|
|
if AType = 'boolean' then Exit('lBool')
|
|
else if AType = 'float' then Exit('lFloat')
|
|
else Exit('lInt');
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.GetJavaTypeConverter(AType: string): string;
|
|
begin
|
|
if AType = 'boolean' then Exit('lBool')
|
|
else if AType = 'int' then Exit('lInt')
|
|
else if AType = 'float' then Exit('lFloat')
|
|
else if (AType = 'CharSequence') or (AType = 'String') then
|
|
Result := Format('(%s) MyJavaLang.LangElements.get(lInt)', [AType])
|
|
else Result := Format('(%s) ViewElements.get(lInt)', [AType]);
|
|
end;
|
|
|
|
// We add the method num too for overloaded routines
|
|
function TAndroidSDKBindingsGen.GetIDString(AMethodName: string): string;
|
|
begin
|
|
Result := Format('amkUI_%s_%s_%d', [FClassNamePas, AMethodName, FMethodNum]);
|
|
Result := ConvertJavaSpecialCharsToUnderline(Result);
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.AddOutputIDs(AIDString: string);
|
|
begin
|
|
FPasOutputIDs.Add(' ' + AIDString + ' = $' + IntToHex(FClassNum*$1000+FMethodNum, 8) + ';');
|
|
FJavaOutputIDs.Add(' static final int ' + AIDString + ' = 0x' + IntToHex(FClassNum*$1000+FMethodNum, 8) + ';');
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.ConvertJavaSpecialCharsToUnderline(AStr: string): string;
|
|
begin
|
|
Result := StringReplace(AStr, '.', '_', [rfReplaceAll, rfIgnoreCase]);
|
|
Result := StringReplace(Result, '<', '_', [rfReplaceAll]);
|
|
Result := StringReplace(Result, '>', '_', [rfReplaceAll]);
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.ConvertPointToUnderline(AStr: string): string;
|
|
begin
|
|
Result := StringReplace(AStr, '.', '_', [rfReplaceAll, rfIgnoreCase]);
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.JavaRemoveGeneric(AStr: string): string;
|
|
begin
|
|
Result := StringReplace(AStr, '<', '_', [rfReplaceAll]);
|
|
Result := StringReplace(Result, '>', '_', [rfReplaceAll]);
|
|
end;
|
|
|
|
function TAndroidSDKBindingsGen.IsBasicJavaType(AStr: string): Boolean;
|
|
begin
|
|
Result := (AStr = 'boolean') or (AStr = 'int') or (AStr = 'float');
|
|
end;
|
|
|
|
constructor TAndroidSDKBindingsGen.Create;
|
|
begin
|
|
FSourceFile := TStringList.Create;
|
|
|
|
FPasOutputTypes := TStringList.Create;
|
|
FPasOutputClassesForward := TStringList.Create;
|
|
FPasOutputClasses := TStringList.Create;
|
|
FPasOutputImpl := TStringList.Create;
|
|
FPasOutputIDs := TStringList.Create;
|
|
FPasOutputConsts := TStringList.Create;
|
|
FPasOutputMessages := TStringList.Create;
|
|
FPasGlobalVars := TStringList.Create;
|
|
FPasInitialization := TStringList.Create;
|
|
|
|
FJavaOutputIDs := TStringList.Create;
|
|
FJavaOutputMethods := TStringList.Create;
|
|
|
|
FCallbackTypesJavaName := TStringList.Create;
|
|
FCallbackTypesParams := TStringList.Create;
|
|
FCallbackTypesInnerName := TStringList.Create;
|
|
FCallbackTypesFirstParam := TStringList.Create;
|
|
|
|
FClassNum := $100;
|
|
end;
|
|
|
|
destructor TAndroidSDKBindingsGen.Destroy;
|
|
begin
|
|
FSourceFile.Free;
|
|
|
|
FPasOutputTypes.Free;
|
|
FPasOutputClassesForward.Free;
|
|
FPasOutputClasses.Free;
|
|
FPasOutputImpl.Free;
|
|
FPasOutputIDs.Free;
|
|
FPasOutputConsts.Free;
|
|
FPasOutputMessages.Free;
|
|
FPasGlobalVars.Free;
|
|
FPasInitialization.Free;
|
|
|
|
FJavaOutputIDs.Free;
|
|
FJavaOutputMethods.Free;
|
|
|
|
FCallbackTypesJavaName.Free;
|
|
FCallbackTypesParams.Free;
|
|
FCallbackTypesInnerName.Free;
|
|
FCallbackTypesFirstParam.Free;
|
|
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TAndroidSDKBindingsGen.GenerateAllBindings(AInputDir, APasOutputDir,
|
|
AJavaOutputDir: string);
|
|
begin
|
|
ProcessModelFile(IncludeTrailingPathDelimiter(AInputDir) + 'android_all.txt',
|
|
IncludeTrailingPathDelimiter(APasOutputDir) + 'android_all.pas',
|
|
IncludeTrailingPathDelimiter(AJavaOutputDir) + 'AndroidAll.java');
|
|
end;
|
|
|
|
initialization
|
|
|
|
AndroidSDKBindingsGen := TAndroidSDKBindingsGen.Create;
|
|
|
|
finalization
|
|
|
|
AndroidSDKBindingsGen.Free;
|
|
|
|
end.
|
|
|