diff --git a/.gitignore b/.gitignore index 71eff6fc..c0e6eab7 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,24 @@ /src/KeePassLib2Android/bin /src/KeePass.userprefs /src/keepass2android/Properties/AndroidManifest.xml + +/src/java/kbbridge/bin/AndroidManifest.xml +/src/java/kbbridge/bin/R.txt +/src/java/kbbridge/bin/classes/keepass2android/kbbridge/BuildConfig.class +/src/java/kbbridge/bin/classes/keepass2android/kbbridge/KeyboardData.class +/src/java/kbbridge/bin/classes/keepass2android/kbbridge/KeyboardDataBuilder.class +/src/java/kbbridge/bin/classes/keepass2android/kbbridge/R$attr.class +/src/java/kbbridge/bin/classes/keepass2android/kbbridge/R$drawable.class +/src/java/kbbridge/bin/classes/keepass2android/kbbridge/R$string.class +/src/java/kbbridge/bin/classes/keepass2android/kbbridge/R$style.class +/src/java/kbbridge/bin/classes/keepass2android/kbbridge/R.class +/src/java/kbbridge/bin/kp2asoftkeyboardbridge.jar +/src/java/kbbridge/bin/res/drawable-hdpi/ic_launcher.png +/src/java/kbbridge/bin/res/drawable-mdpi/ic_launcher.png +/src/java/kbbridge/bin/res/drawable-xhdpi/ic_launcher.png + +/src/java/kbbridge/libs/android-support-v4.jar +/src/java/KP2ASoftKeyboard/bin +/src/java/KP2ASoftKeyboard/gen +/src/java/KP2ASoftKeyboard/projectzip +/src/java/KP2ASoftKeyboard/createProjectZip.bat diff --git a/src/KP2AKeyboard/Additions/AboutAdditions.txt b/src/KP2AKeyboard/Additions/AboutAdditions.txt new file mode 100644 index 00000000..9141ebd7 --- /dev/null +++ b/src/KP2AKeyboard/Additions/AboutAdditions.txt @@ -0,0 +1,48 @@ +Additions allow you to add arbitrary C# to the generated classes +before they are compiled. This can be helpful for providing convenience +methods or adding pure C# classes. + +== Adding Methods to Generated Classes == + +Let's say the library being bound has a Rectangle class with a constructor +that takes an x and y position, and a width and length size. It will look like +this: + +public partial class Rectangle +{ + public Rectangle (int x, int y, int width, int height) + { + // JNI bindings + } +} + +Imagine we want to add a constructor to this class that takes a Point and +Size structure instead of 4 ints. We can add a new file called Rectangle.cs +with a partial class containing our new method: + +public partial class Rectangle +{ + public Rectangle (Point location, Size size) : + this (location.X, location.Y, size.Width, size.Height) + { + } +} + +At compile time, the additions class will be added to the generated class +and the final assembly will a Rectangle class with both constructors. + + +== Adding C# Classes == + +Another thing that can be done is adding fully C# managed classes to the +generated library. In the above example, let's assume that there isn't a +Point class available in Java or our library. The one we create doesn't need +to interact with Java, so we'll create it like a normal class in C#. + +By adding a Point.cs file with this class, it will end up in the binding library: + +public class Point +{ + public int X { get; set; } + public int Y { get; set; } +} diff --git a/src/KP2AKeyboard/KP2AKeyboard.csproj b/src/KP2AKeyboard/KP2AKeyboard.csproj new file mode 100644 index 00000000..2705f474 --- /dev/null +++ b/src/KP2AKeyboard/KP2AKeyboard.csproj @@ -0,0 +1,59 @@ + + + + Debug + AnyCPU + 10.0.0 + 2.0 + {4F9D8890-82EE-4A3B-8E98-61B00B5AADAA} + {EFBA0AD7-5A72-4C68-AF49-83D382785DCF};{10368E6C-D01B-4462-8E8B-01FC667A7035};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Library + KP2AKeyboard + Resources + Assets + KP2AKeyboard + + + True + full + False + bin\Debug + DEBUG; + 4 + False + None + + + none + True + bin\Release + 4 + False + False + SdkOnly + + + + + + + + + + + + + + + + + + + + + + project.zip + Always + + + \ No newline at end of file diff --git a/src/KP2AKeyboard/Properties/AssemblyInfo.cs b/src/KP2AKeyboard/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..c67f8b19 --- /dev/null +++ b/src/KP2AKeyboard/Properties/AssemblyInfo.cs @@ -0,0 +1,28 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using Android.App; + +// Information about this assembly is defined by the following attributes. +// Change them to the values specific to your project. + +[assembly: AssemblyTitle("KP2AKeyboard")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("")] +[assembly: AssemblyCopyright("Philipp")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}". +// The form "{Major}.{Minor}.*" will automatically update the build and revision, +// and "{Major}.{Minor}.{Build}.*" will update just the revision. + +[assembly: AssemblyVersion("1.0.0")] + +// The following attributes are used to specify the signing key for the assembly, +// if desired. See the Mono documentation for more information about signing. + +//[assembly: AssemblyDelaySign(false)] +//[assembly: AssemblyKeyFile("")] + diff --git a/src/KP2AKeyboard/Resources/AboutResources.txt b/src/KP2AKeyboard/Resources/AboutResources.txt new file mode 100644 index 00000000..54c2267a --- /dev/null +++ b/src/KP2AKeyboard/Resources/AboutResources.txt @@ -0,0 +1,44 @@ +Images, layout descriptions, binary blobs and string dictionaries can be included +in your application as resource files. Various Android APIs are designed to +operate on the resource IDs instead of dealing with images, strings or binary blobs +directly. + +For example, a sample Android app that contains a user interface layout (main.axml), +an internationalization string table (strings.xml) and some icons (drawable-XXX/icon.png) +would keep its resources in the "Resources" directory of the application: + +Resources/ + drawable/ + icon.png + + layout/ + main.axml + + values/ + strings.xml + +In order to get the build system to recognize Android resources, set the build action to +"AndroidResource". The native Android APIs do not operate directly with filenames, but +instead operate on resource IDs. When you compile an Android application that uses resources, +the build system will package the resources for distribution and generate a class called "R" +(this is an Android convention) that contains the tokens for each one of the resources +included. For example, for the above Resources layout, this is what the R class would expose: + +public class R { + public class drawable { + public const int icon = 0x123; + } + + public class layout { + public const int main = 0x456; + } + + public class strings { + public const int first_string = 0xabc; + public const int second_string = 0xbcd; + } +} + +You would then use R.drawable.icon to reference the drawable/icon.png file, or R.layout.main +to reference the layout/main.axml file, or R.strings.first_string to reference the first +string in the dictionary file values/strings.xml. diff --git a/src/KP2AKeyboard/Resources/Resource.designer.cs b/src/KP2AKeyboard/Resources/Resource.designer.cs new file mode 100644 index 00000000..a7963b30 --- /dev/null +++ b/src/KP2AKeyboard/Resources/Resource.designer.cs @@ -0,0 +1,42 @@ +#pragma warning disable 1591 +//------------------------------------------------------------------------------ +// +// Dieser Code wurde von einem Tool generiert. +// Laufzeitversion:4.0.30319.296 +// +// Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn +// der Code erneut generiert wird. +// +//------------------------------------------------------------------------------ + +[assembly: Android.Runtime.ResourceDesignerAttribute("KP2AKeyboard.Resource", IsApplication=false)] + +namespace KP2AKeyboard +{ + + + [System.CodeDom.Compiler.GeneratedCodeAttribute("Novell.MonoDroid.Build.Tasks", "1.0.0.0")] + public partial class Resource + { + + public partial class Attribute + { + + private Attribute() + { + } + } + + public partial class String + { + + // aapt resource value: 0x7f020000 + public static int library_name = 2130837504; + + private String() + { + } + } + } +} +#pragma warning restore 1591 diff --git a/src/KP2AKeyboard/Resources/values/Strings.xml b/src/KP2AKeyboard/Resources/values/Strings.xml new file mode 100644 index 00000000..f89a894f --- /dev/null +++ b/src/KP2AKeyboard/Resources/values/Strings.xml @@ -0,0 +1,4 @@ + + + KP2AKeyboard + diff --git a/src/KP2AKeyboard/Transforms/EnumFields.xml b/src/KP2AKeyboard/Transforms/EnumFields.xml new file mode 100644 index 00000000..b3aca487 --- /dev/null +++ b/src/KP2AKeyboard/Transforms/EnumFields.xml @@ -0,0 +1,14 @@ + + + diff --git a/src/KP2AKeyboard/Transforms/EnumMethods.xml b/src/KP2AKeyboard/Transforms/EnumMethods.xml new file mode 100644 index 00000000..0ffc15ca --- /dev/null +++ b/src/KP2AKeyboard/Transforms/EnumMethods.xml @@ -0,0 +1,11 @@ + + + diff --git a/src/KP2AKeyboard/Transforms/Metadata.xml b/src/KP2AKeyboard/Transforms/Metadata.xml new file mode 100644 index 00000000..87ac70dc --- /dev/null +++ b/src/KP2AKeyboard/Transforms/Metadata.xml @@ -0,0 +1,9 @@ + + + diff --git a/src/KeePass.sln b/src/KeePass.sln index 9e97eeaf..0b73d48e 100644 --- a/src/KeePass.sln +++ b/src/KeePass.sln @@ -7,6 +7,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "keepass2android", "keepass2 EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "kp2akeytransform", "kp2akeytransform\kp2akeytransform.csproj", "{A57B3ACE-5634-469A-88C4-858BB409F356}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Kp2aKeyboardBinding", "Kp2aKeyboardBinding\Kp2aKeyboardBinding.csproj", "{A8779D4D-7C49-4C2F-82BD-2CDC448391DA}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -74,6 +76,24 @@ Global {A6CF8A86-37C1-4197-80FE-519DE2C842F5}.Release|x64.Build.0 = Release|Any CPU {A6CF8A86-37C1-4197-80FE-519DE2C842F5}.ReleaseNoNet|Any CPU.ActiveCfg = ReleaseNoNet|Any CPU {A6CF8A86-37C1-4197-80FE-519DE2C842F5}.ReleaseNoNet|Any CPU.Build.0 = ReleaseNoNet|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Debug|Win32.ActiveCfg = Debug|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Debug|Win32.Build.0 = Debug|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Debug|x64.ActiveCfg = Debug|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Debug|x64.Build.0 = Debug|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Release|Any CPU.Build.0 = Release|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Release|Win32.ActiveCfg = Release|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Release|Win32.Build.0 = Release|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Release|x64.ActiveCfg = Release|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.Release|x64.Build.0 = Release|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.ReleaseNoNet|Any CPU.ActiveCfg = Debug|Any CPU + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA}.ReleaseNoNet|Any CPU.Build.0 = Debug|Any CPU EndGlobalSection GlobalSection(MonoDevelopProperties) = preSolution diff --git a/src/Kp2aKeyboardBinding/Additions/AboutAdditions.txt b/src/Kp2aKeyboardBinding/Additions/AboutAdditions.txt new file mode 100644 index 00000000..9141ebd7 --- /dev/null +++ b/src/Kp2aKeyboardBinding/Additions/AboutAdditions.txt @@ -0,0 +1,48 @@ +Additions allow you to add arbitrary C# to the generated classes +before they are compiled. This can be helpful for providing convenience +methods or adding pure C# classes. + +== Adding Methods to Generated Classes == + +Let's say the library being bound has a Rectangle class with a constructor +that takes an x and y position, and a width and length size. It will look like +this: + +public partial class Rectangle +{ + public Rectangle (int x, int y, int width, int height) + { + // JNI bindings + } +} + +Imagine we want to add a constructor to this class that takes a Point and +Size structure instead of 4 ints. We can add a new file called Rectangle.cs +with a partial class containing our new method: + +public partial class Rectangle +{ + public Rectangle (Point location, Size size) : + this (location.X, location.Y, size.Width, size.Height) + { + } +} + +At compile time, the additions class will be added to the generated class +and the final assembly will a Rectangle class with both constructors. + + +== Adding C# Classes == + +Another thing that can be done is adding fully C# managed classes to the +generated library. In the above example, let's assume that there isn't a +Point class available in Java or our library. The one we create doesn't need +to interact with Java, so we'll create it like a normal class in C#. + +By adding a Point.cs file with this class, it will end up in the binding library: + +public class Point +{ + public int X { get; set; } + public int Y { get; set; } +} diff --git a/src/Kp2aKeyboardBinding/Jars/AboutJars.txt b/src/Kp2aKeyboardBinding/Jars/AboutJars.txt new file mode 100644 index 00000000..9a14c103 --- /dev/null +++ b/src/Kp2aKeyboardBinding/Jars/AboutJars.txt @@ -0,0 +1,37 @@ +This directory is for Android .jars. + +There are 3 types of jars that are supported: + +== Input Jar and Embedded Jar == + +This is the jar that bindings should be generated for. + +For example, if you were binding the Google Maps library, this would +be Google's "maps.jar". + +The difference between EmbeddedJar and InputJar is, EmbeddedJar is to be +embedded in the resulting dll as EmbeddedResource, while InputJar is not. +There are couple of reasons you wouldn't like to embed the target jar +in your dll (the ones that could be internally loaded by +feature e.g. maps.jar, or you cannot embed jars that are under some +proprietary license). + +Set the build action for these jars in the properties page to "InputJar". + + +== Reference Jar and Embedded Reference Jar == + +These are jars that are referenced by the input jar. C# bindings will +not be created for these jars. These jars will be used to resolve +types used by the input jar. + +NOTE: Do not add "android.jar" as a reference jar. It will be added automatically +based on the Target Framework selected. + +Set the build action for these jars in the properties page to "ReferenceJar". + +"EmbeddedJar" works like "ReferenceJar", but like "EmbeddedJar", it is +embedded in your dll. But at application build time, they are not included +in the final apk, like ReferenceJar files. + + diff --git a/src/Kp2aKeyboardBinding/Kp2aKeyboardBinding.csproj b/src/Kp2aKeyboardBinding/Kp2aKeyboardBinding.csproj new file mode 100644 index 00000000..30ce0f23 --- /dev/null +++ b/src/Kp2aKeyboardBinding/Kp2aKeyboardBinding.csproj @@ -0,0 +1,61 @@ + + + + Debug + AnyCPU + 10.0.0 + 2.0 + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA} + {EFBA0AD7-5A72-4C68-AF49-83D382785DCF};{10368E6C-D01B-4462-8E8B-01FC667A7035};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Library + Kp2aKeyboardBinding + Assets + Resources + Kp2aKeyboardBinding + + + True + full + False + bin\Debug + DEBUG; + prompt + 4 + False + None + + + none + True + bin\Release + prompt + 4 + False + False + SdkOnly + + + + + + + + + + + + + + + + + + + + + + + project.zip + + + \ No newline at end of file diff --git a/src/Kp2aKeyboardBinding/Properties/AssemblyInfo.cs b/src/Kp2aKeyboardBinding/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..a8aed884 --- /dev/null +++ b/src/Kp2aKeyboardBinding/Properties/AssemblyInfo.cs @@ -0,0 +1,28 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using Android.App; + +// Information about this assembly is defined by the following attributes. +// Change them to the values specific to your project. + +[assembly: AssemblyTitle("Kp2aKeyboardBinding")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("")] +[assembly: AssemblyCopyright("Philipp")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}". +// The form "{Major}.{Minor}.*" will automatically update the build and revision, +// and "{Major}.{Minor}.{Build}.*" will update just the revision. + +[assembly: AssemblyVersion("1.0.0")] + +// The following attributes are used to specify the signing key for the assembly, +// if desired. See the Mono documentation for more information about signing. + +//[assembly: AssemblyDelaySign(false)] +//[assembly: AssemblyKeyFile("")] + diff --git a/src/Kp2aKeyboardBinding/Transforms/EnumFields.xml b/src/Kp2aKeyboardBinding/Transforms/EnumFields.xml new file mode 100644 index 00000000..b3aca487 --- /dev/null +++ b/src/Kp2aKeyboardBinding/Transforms/EnumFields.xml @@ -0,0 +1,14 @@ + + + diff --git a/src/Kp2aKeyboardBinding/Transforms/EnumMethods.xml b/src/Kp2aKeyboardBinding/Transforms/EnumMethods.xml new file mode 100644 index 00000000..0ffc15ca --- /dev/null +++ b/src/Kp2aKeyboardBinding/Transforms/EnumMethods.xml @@ -0,0 +1,11 @@ + + + diff --git a/src/Kp2aKeyboardBinding/Transforms/Metadata.xml b/src/Kp2aKeyboardBinding/Transforms/Metadata.xml new file mode 100644 index 00000000..87ac70dc --- /dev/null +++ b/src/Kp2aKeyboardBinding/Transforms/Metadata.xml @@ -0,0 +1,9 @@ + + + diff --git a/src/java/KP2ASoftKeyboard/.classpath b/src/java/KP2ASoftKeyboard/.classpath index a4763d1e..3f9691c5 100644 --- a/src/java/KP2ASoftKeyboard/.classpath +++ b/src/java/KP2ASoftKeyboard/.classpath @@ -1,8 +1,8 @@ - - + + diff --git a/src/java/KP2ASoftKeyboard/AndroidManifest.xml b/src/java/KP2ASoftKeyboard/AndroidManifest.xml index 27da654f..71182870 100644 --- a/src/java/KP2ASoftKeyboard/AndroidManifest.xml +++ b/src/java/KP2ASoftKeyboard/AndroidManifest.xml @@ -1,6 +1,6 @@ - + package="keepass2android.softkeyboard" android:versionCode="1"> + \u0020.,;:!?\n()[]*&@{}/<>_+=|" + Select another entry + Select entry + Go Next diff --git a/src/java/KP2ASoftKeyboard/res/xml/qwerty.xml b/src/java/KP2ASoftKeyboard/res/xml/qwerty.xml index afee012a..839b5dbe 100644 --- a/src/java/KP2ASoftKeyboard/res/xml/qwerty.xml +++ b/src/java/KP2ASoftKeyboard/res/xml/qwerty.xml @@ -68,8 +68,10 @@ - + + diff --git a/src/java/KP2ASoftKeyboard/src/keepass2android/kbbridge/KeyboardData.java b/src/java/KP2ASoftKeyboard/src/keepass2android/kbbridge/KeyboardData.java new file mode 100644 index 00000000..dea665c4 --- /dev/null +++ b/src/java/KP2ASoftKeyboard/src/keepass2android/kbbridge/KeyboardData.java @@ -0,0 +1,12 @@ + +package keepass2android.kbbridge; +import java.util.HashMap; +public class KeyboardData { + public static HashMap availableFields = new HashMap(); + public static String entryName; + + public static void clear() + { + availableFields.clear(); + } +} diff --git a/src/java/kbbridge/src/keepass2android/kbbridge/KeyboardDataBuilder.java b/src/java/KP2ASoftKeyboard/src/keepass2android/kbbridge/KeyboardDataBuilder.java similarity index 100% rename from src/java/kbbridge/src/keepass2android/kbbridge/KeyboardDataBuilder.java rename to src/java/KP2ASoftKeyboard/src/keepass2android/kbbridge/KeyboardDataBuilder.java diff --git a/src/java/KP2ASoftKeyboard/src/keepass2android/softkeyboard/KP2AKeyboard.java b/src/java/KP2ASoftKeyboard/src/keepass2android/softkeyboard/KP2AKeyboard.java index 86131e2d..33ee8dc8 100644 --- a/src/java/KP2ASoftKeyboard/src/keepass2android/softkeyboard/KP2AKeyboard.java +++ b/src/java/KP2ASoftKeyboard/src/keepass2android/softkeyboard/KP2AKeyboard.java @@ -17,10 +17,14 @@ package keepass2android.softkeyboard; import android.app.AlertDialog; +import android.content.ComponentName; import android.content.DialogInterface; +import android.content.Intent; +import android.content.pm.PackageManager; import android.inputmethodservice.InputMethodService; import android.inputmethodservice.Keyboard; import android.inputmethodservice.KeyboardView; +import android.provider.Settings; import android.text.InputType; import android.view.KeyEvent; import android.view.View; @@ -33,613 +37,672 @@ import android.view.inputmethod.InputMethodManager; import android.view.inputmethod.InputMethodSubtype; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import keepass2android.softkeyboard.R; /** - * Example of writing an input method for a soft keyboard. This code is - * focused on simplicity over completeness, so it should in no way be considered - * to be a complete soft keyboard implementation. Its purpose is to provide - * a basic example for how you would get started writing an input method, to - * be fleshed out as appropriate. + * Example of writing an input method for a soft keyboard. This code is focused + * on simplicity over completeness, so it should in no way be considered to be a + * complete soft keyboard implementation. Its purpose is to provide a basic + * example for how you would get started writing an input method, to be fleshed + * out as appropriate. */ -public class KP2AKeyboard extends InputMethodService - implements KeyboardView.OnKeyboardActionListener { - static final boolean DEBUG = false; - - private InputMethodManager mInputMethodManager; +public class KP2AKeyboard extends InputMethodService implements + KeyboardView.OnKeyboardActionListener { + static final boolean DEBUG = false; - private LatinKeyboardView mInputView; - private CandidateView mCandidateView; - private CompletionInfo[] mCompletions; - - private StringBuilder mComposing = new StringBuilder(); - private boolean mPredictionOn; - private boolean mCompletionOn; - private int mLastDisplayWidth; - private boolean mCapsLock; - private long mLastShiftTime; - private long mMetaState; - - private LatinKeyboard mSymbolsKeyboard; - private LatinKeyboard mSymbolsShiftedKeyboard; - private LatinKeyboard mQwertyKeyboard; - - private LatinKeyboard mCurKeyboard; - - private String mWordSeparators; - - /** - * Main initialization of the input method component. Be sure to call - * to super class. - */ - @Override public void onCreate() { - super.onCreate(); - mInputMethodManager = (InputMethodManager)getSystemService(INPUT_METHOD_SERVICE); - mWordSeparators = getResources().getString(R.string.word_separators); - } - - /** - * This is the point where you can do all of your UI initialization. It - * is called after creation and any configuration change. - */ - @Override public void onInitializeInterface() { - if (mQwertyKeyboard != null) { - // Configuration changes can happen after the keyboard gets recreated, - // so we need to be able to re-build the keyboards if the available - // space has changed. - int displayWidth = getMaxWidth(); - if (displayWidth == mLastDisplayWidth) return; - mLastDisplayWidth = displayWidth; - } - mQwertyKeyboard = new LatinKeyboard(this, R.xml.qwerty); - mSymbolsKeyboard = new LatinKeyboard(this, R.xml.symbols); - mSymbolsShiftedKeyboard = new LatinKeyboard(this, R.xml.symbols_shift); - } - - /** - * Called by the framework when your view for creating input needs to - * be generated. This will be called the first time your input method - * is displayed, and every time it needs to be re-created such as due to - * a configuration change. - */ - @Override public View onCreateInputView() { - mInputView = (LatinKeyboardView) getLayoutInflater().inflate( - R.layout.input, null); - mInputView.setOnKeyboardActionListener(this); - mInputView.setKeyboard(mQwertyKeyboard); - return mInputView; - } + private InputMethodManager mInputMethodManager; - /** - * Called by the framework when your view for showing candidates needs to - * be generated, like {@link #onCreateInputView}. - */ - @Override public View onCreateCandidatesView() { - mCandidateView = new CandidateView(this); - mCandidateView.setService(this); - return mCandidateView; - } + private LatinKeyboardView mInputView; + private CandidateView mCandidateView; + private CompletionInfo[] mCompletions; - /** - * This is the main point where we do our initialization of the input method - * to begin operating on an application. At this point we have been - * bound to the client, and are now receiving all of the detailed information - * about the target of our edits. - */ - @Override public void onStartInput(EditorInfo attribute, boolean restarting) { - super.onStartInput(attribute, restarting); - - // Reset our state. We want to do this even if restarting, because - // the underlying state of the text editor could have changed in any way. - mComposing.setLength(0); - updateCandidates(); - - if (!restarting) { - // Clear shift states. - mMetaState = 0; - } - - mPredictionOn = false; - mCompletionOn = false; - mCompletions = null; - - // We are now going to initialize our state based on the type of - // text being edited. - switch (attribute.inputType & InputType.TYPE_MASK_CLASS) { - case InputType.TYPE_CLASS_NUMBER: - case InputType.TYPE_CLASS_DATETIME: - // Numbers and dates default to the symbols keyboard, with - // no extra features. - mCurKeyboard = mSymbolsKeyboard; - break; - - case InputType.TYPE_CLASS_PHONE: - // Phones will also default to the symbols keyboard, though - // often you will want to have a dedicated phone keyboard. - mCurKeyboard = mSymbolsKeyboard; - break; - - case InputType.TYPE_CLASS_TEXT: - // This is general text editing. We will default to the - // normal alphabetic keyboard, and assume that we should - // be doing predictive text (showing candidates as the - // user types). - mCurKeyboard = mQwertyKeyboard; - mPredictionOn = true; - - // We now look for a few special variations of text that will - // modify our behavior. - int variation = attribute.inputType & InputType.TYPE_MASK_VARIATION; - if (variation == InputType.TYPE_TEXT_VARIATION_PASSWORD || - variation == InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD) { - // Do not display predictions / what the user is typing - // when they are entering a password. - mPredictionOn = false; - } - - if (variation == InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS - || variation == InputType.TYPE_TEXT_VARIATION_URI - || variation == InputType.TYPE_TEXT_VARIATION_FILTER) { - // Our predictions are not useful for e-mail addresses - // or URIs. - mPredictionOn = false; - } - - if ((attribute.inputType & InputType.TYPE_TEXT_FLAG_AUTO_COMPLETE) != 0) { - // If this is an auto-complete text view, then our predictions - // will not be shown and instead we will allow the editor - // to supply their own. We only show the editor's - // candidates when in fullscreen mode, otherwise relying - // own it displaying its own UI. - mPredictionOn = false; - mCompletionOn = isFullscreenMode(); - } - - // We also want to look at the current state of the editor - // to decide whether our alphabetic keyboard should start out - // shifted. - updateShiftKeyState(attribute); - break; - - default: - // For all unknown input types, default to the alphabetic - // keyboard with no special features. - mCurKeyboard = mQwertyKeyboard; - updateShiftKeyState(attribute); - } - - // Update the label on the enter key, depending on what the application - // says it will do. - mCurKeyboard.setImeOptions(getResources(), attribute.imeOptions); - } + private StringBuilder mComposing = new StringBuilder(); + private boolean mPredictionOn; + private boolean mCompletionOn; + private int mLastDisplayWidth; + private boolean mCapsLock; + private long mLastShiftTime; + private long mMetaState; - /** - * This is called when the user is done editing a field. We can use - * this to reset our state. - */ - @Override public void onFinishInput() { - super.onFinishInput(); - - // Clear current composing text and candidates. - mComposing.setLength(0); - updateCandidates(); - - // We only hide the candidates window when finishing input on - // a particular editor, to avoid popping the underlying application - // up and down if the user is entering text into the bottom of - // its window. - setCandidatesViewShown(false); - - mCurKeyboard = mQwertyKeyboard; - if (mInputView != null) { - mInputView.closing(); - } - } - - @Override public void onStartInputView(EditorInfo attribute, boolean restarting) { - super.onStartInputView(attribute, restarting); - // Apply the selected keyboard to the input view. - mInputView.setKeyboard(mCurKeyboard); - mInputView.closing(); - //final InputMethodSubtype subtype = mInputMethodManager.getCurrentInputMethodSubtype(); - //mInputView.setSubtypeOnSpaceKey(subtype); - } + private LatinKeyboard mSymbolsKeyboard; + private LatinKeyboard mSymbolsShiftedKeyboard; + private LatinKeyboard mQwertyKeyboard; - @Override - public void onCurrentInputMethodSubtypeChanged(InputMethodSubtype subtype) { - mInputView.setSubtypeOnSpaceKey(subtype); - } + private LatinKeyboard mCurKeyboard; - /** - * Deal with the editor reporting movement of its cursor. - */ - @Override public void onUpdateSelection(int oldSelStart, int oldSelEnd, - int newSelStart, int newSelEnd, - int candidatesStart, int candidatesEnd) { - super.onUpdateSelection(oldSelStart, oldSelEnd, newSelStart, newSelEnd, - candidatesStart, candidatesEnd); - - // If the current selection in the text view changes, we should - // clear whatever candidate text we have. - if (mComposing.length() > 0 && (newSelStart != candidatesEnd - || newSelEnd != candidatesEnd)) { - mComposing.setLength(0); - updateCandidates(); - InputConnection ic = getCurrentInputConnection(); - if (ic != null) { - ic.finishComposingText(); - } - } - } + private String mWordSeparators; - /** - * This tells us about completions that the editor has determined based - * on the current text in it. We want to use this in fullscreen mode - * to show the completions ourself, since the editor can not be seen - * in that situation. - */ - @Override public void onDisplayCompletions(CompletionInfo[] completions) { - if (mCompletionOn) { - mCompletions = completions; - if (completions == null) { - setSuggestions(null, false, false); - return; - } - - List stringList = new ArrayList(); - for (int i = 0; i < completions.length; i++) { - CompletionInfo ci = completions[i]; - if (ci != null) stringList.add(ci.getText().toString()); - } - setSuggestions(stringList, true, true); - } - } - - - /** - * Use this to monitor key events being delivered to the application. - * We get first crack at them, and can either resume them or let them - * continue to the app. - */ - @Override public boolean onKeyDown(int keyCode, KeyEvent event) { - switch (keyCode) { - case KeyEvent.KEYCODE_BACK: - // The InputMethodService already takes care of the back - // key for us, to dismiss the input method if it is shown. - // However, our keyboard could be showing a pop-up window - // that back should dismiss, so we first allow it to do that. - if (event.getRepeatCount() == 0 && mInputView != null) { - if (mInputView.handleBack()) { - return true; - } - } - break; - - case KeyEvent.KEYCODE_DEL: - // Special handling of the delete key: if we currently are - // composing text for the user, we want to modify that instead - // of let the application to the delete itself. - if (mComposing.length() > 0) { - onKey(Keyboard.KEYCODE_DELETE, null); - return true; - } - break; - - case KeyEvent.KEYCODE_ENTER: - // Let the underlying text editor always handle these. - return false; - - default: - - } - - return super.onKeyDown(keyCode, event); - } + /** + * Main initialization of the input method component. Be sure to call to + * super class. + */ + @Override + public void onCreate() { + super.onCreate(); + mInputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE); + mWordSeparators = getResources().getString(R.string.word_separators); + } + /** + * This is the point where you can do all of your UI initialization. It is + * called after creation and any configuration change. + */ + @Override + public void onInitializeInterface() { + if (mQwertyKeyboard != null) { + // Configuration changes can happen after the keyboard gets + // recreated, + // so we need to be able to re-build the keyboards if the available + // space has changed. + int displayWidth = getMaxWidth(); + if (displayWidth == mLastDisplayWidth) + return; + mLastDisplayWidth = displayWidth; + } + mQwertyKeyboard = new LatinKeyboard(this, R.xml.qwerty); + mSymbolsKeyboard = new LatinKeyboard(this, R.xml.symbols); + mSymbolsShiftedKeyboard = new LatinKeyboard(this, R.xml.symbols_shift); + } - /** - * Helper function to commit any text being composed in to the editor. - */ - private void commitTyped(InputConnection inputConnection) { - if (mComposing.length() > 0) { - inputConnection.commitText(mComposing, mComposing.length()); - mComposing.setLength(0); - updateCandidates(); - } - } + /** + * Called by the framework when your view for creating input needs to be + * generated. This will be called the first time your input method is + * displayed, and every time it needs to be re-created such as due to a + * configuration change. + */ + @Override + public View onCreateInputView() { + mInputView = (LatinKeyboardView) getLayoutInflater().inflate( + R.layout.input, null); + mInputView.setOnKeyboardActionListener(this); + mInputView.setKeyboard(mQwertyKeyboard); + return mInputView; + } - /** - * Helper to update the shift state of our keyboard based on the initial - * editor state. - */ - private void updateShiftKeyState(EditorInfo attr) { - if (attr != null - && mInputView != null && mQwertyKeyboard == mInputView.getKeyboard()) { - int caps = 0; - EditorInfo ei = getCurrentInputEditorInfo(); - if (ei != null && ei.inputType != InputType.TYPE_NULL) { - caps = getCurrentInputConnection().getCursorCapsMode(attr.inputType); - } - mInputView.setShifted(mCapsLock || caps != 0); - } - } - - /** - * Helper to determine if a given character code is alphabetic. - */ - private boolean isAlphabet(int code) { - if (Character.isLetter(code)) { - return true; - } else { - return false; - } - } - - /** - * Helper to send a key down / key up pair to the current editor. - */ - private void keyDownUp(int keyEventCode) { - getCurrentInputConnection().sendKeyEvent( - new KeyEvent(KeyEvent.ACTION_DOWN, keyEventCode)); - getCurrentInputConnection().sendKeyEvent( - new KeyEvent(KeyEvent.ACTION_UP, keyEventCode)); - } - - /** - * Helper to send a character to the editor as raw key events. - */ - private void sendKey(int keyCode) { - switch (keyCode) { - case '\n': - keyDownUp(KeyEvent.KEYCODE_ENTER); - break; - default: - if (keyCode >= '0' && keyCode <= '9') { - keyDownUp(keyCode - '0' + KeyEvent.KEYCODE_0); - } else { - getCurrentInputConnection().commitText(String.valueOf((char) keyCode), 1); - } - break; - } - } + /** + * Called by the framework when your view for showing candidates needs to be + * generated, like {@link #onCreateInputView}. + */ + @Override + public View onCreateCandidatesView() { + mCandidateView = new CandidateView(this); + mCandidateView.setService(this); + return mCandidateView; + } - // Implementation of KeyboardViewListener + /** + * This is the main point where we do our initialization of the input method + * to begin operating on an application. At this point we have been bound to + * the client, and are now receiving all of the detailed information about + * the target of our edits. + */ + @Override + public void onStartInput(EditorInfo attribute, boolean restarting) { + super.onStartInput(attribute, restarting); - public void onKey(int primaryCode, int[] keyCodes) { - if (isWordSeparator(primaryCode)) { - // Handle separator - if (mComposing.length() > 0) { - commitTyped(getCurrentInputConnection()); - } - sendKey(primaryCode); - updateShiftKeyState(getCurrentInputEditorInfo()); - } else if (primaryCode == Keyboard.KEYCODE_DELETE) { - handleBackspace(); - } else if (primaryCode == Keyboard.KEYCODE_SHIFT) { - handleShift(); - } else if (primaryCode == Keyboard.KEYCODE_CANCEL) { - handleClose(); - return; - } else if (primaryCode == LatinKeyboardView.KEYCODE_KP2A) { - AlertDialog.Builder builder = new AlertDialog.Builder(this); - final CharSequence[] items = {"Gallery Image Menu!", "hello你好", "View pattern", "Delete pattern", "Locate pattern in list view", "Row Counter (with pattern)", "Share Pattern", "Share Image"}; - builder.setTitle("Keepass2Android"); - //builder.setMessage("What do you want to type securely?"); - builder.setItems(items, new DialogInterface.OnClickListener() { - public void onClick(DialogInterface dialog, int item) { + // Reset our state. We want to do this even if restarting, because + // the underlying state of the text editor could have changed in any + // way. + mComposing.setLength(0); + updateCandidates(); - getCurrentInputConnection().commitText(items[item],0); + if (!restarting) { + // Clear shift states. + mMetaState = 0; + } - if (item == 0){ - } + mPredictionOn = false; + mCompletionOn = false; + mCompletions = null; - } - }); - // Add the buttons - builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() { - public void onClick(DialogInterface dialog, int id) { - // User cancelled the dialog - } - }); - // Set other dialog properties + // We are now going to initialize our state based on the type of + // text being edited. + switch (attribute.inputType & InputType.TYPE_MASK_CLASS) { + case InputType.TYPE_CLASS_NUMBER: + case InputType.TYPE_CLASS_DATETIME: + // Numbers and dates default to the symbols keyboard, with + // no extra features. + mCurKeyboard = mSymbolsKeyboard; + break; - // Create the AlertDialog - AlertDialog dialog = builder.create(); - Window window = dialog.getWindow(); - WindowManager.LayoutParams lp = window.getAttributes(); - lp.token = mInputView.getWindowToken(); - lp.type = WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG; - window.setAttributes(lp); - window.addFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); - - dialog.show(); - } else if (primaryCode == LatinKeyboardView.KEYCODE_OPTIONS) { - // Show a menu or somethin' - } else if (primaryCode == Keyboard.KEYCODE_MODE_CHANGE - && mInputView != null) { - Keyboard current = mInputView.getKeyboard(); - if (current == mSymbolsKeyboard || current == mSymbolsShiftedKeyboard) { - current = mQwertyKeyboard; - } else { - current = mSymbolsKeyboard; - } - mInputView.setKeyboard(current); - if (current == mSymbolsKeyboard) { - current.setShifted(false); - } - } else { - handleCharacter(primaryCode, keyCodes); - //mCapsLock = false; - //mInputView.setShifted(mCapsLock); - updateShiftKeyState(getCurrentInputEditorInfo()); - } - } + case InputType.TYPE_CLASS_PHONE: + // Phones will also default to the symbols keyboard, though + // often you will want to have a dedicated phone keyboard. + mCurKeyboard = mSymbolsKeyboard; + break; - public void onText(CharSequence text) { - InputConnection ic = getCurrentInputConnection(); - if (ic == null) return; - ic.beginBatchEdit(); - if (mComposing.length() > 0) { - commitTyped(ic); - } - ic.commitText(text, 0); - ic.endBatchEdit(); - updateShiftKeyState(getCurrentInputEditorInfo()); - } + case InputType.TYPE_CLASS_TEXT: + // This is general text editing. We will default to the + // normal alphabetic keyboard, and assume that we should + // be doing predictive text (showing candidates as the + // user types). + mCurKeyboard = mQwertyKeyboard; + mPredictionOn = true; - /** - * Update the list of available candidates from the current composing - * text. This will need to be filled in by however you are determining - * candidates. - */ - private void updateCandidates() { - if (!mCompletionOn) { - if (mComposing.length() > 0) { - ArrayList list = new ArrayList(); - list.add(mComposing.toString()); - setSuggestions(list, true, true); - } else { - setSuggestions(null, false, false); - } - } - } - - public void setSuggestions(List suggestions, boolean completions, - boolean typedWordValid) { - if (suggestions != null && suggestions.size() > 0) { - setCandidatesViewShown(true); - } else if (isExtractViewShown()) { - setCandidatesViewShown(true); - } - if (mCandidateView != null) { - mCandidateView.setSuggestions(suggestions, completions, typedWordValid); - } - } - - private void handleBackspace() { - final int length = mComposing.length(); - if (length > 1) { - mComposing.delete(length - 1, length); - getCurrentInputConnection().setComposingText(mComposing, 1); - updateCandidates(); - } else if (length > 0) { - mComposing.setLength(0); - getCurrentInputConnection().commitText("", 0); - updateCandidates(); - } else { - keyDownUp(KeyEvent.KEYCODE_DEL); - } - updateShiftKeyState(getCurrentInputEditorInfo()); - } + // We now look for a few special variations of text that will + // modify our behavior. + int variation = attribute.inputType & InputType.TYPE_MASK_VARIATION; + if (variation == InputType.TYPE_TEXT_VARIATION_PASSWORD + || variation == InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD) { + // Do not display predictions / what the user is typing + // when they are entering a password. + mPredictionOn = false; + } - private void handleShift() { - if (mInputView == null) { - return; - } - - Keyboard currentKeyboard = mInputView.getKeyboard(); - if (mQwertyKeyboard == currentKeyboard) { - // Alphabet keyboard - checkToggleCapsLock(); - mInputView.setShifted(mCapsLock || !mInputView.isShifted()); - + if (variation == InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS + || variation == InputType.TYPE_TEXT_VARIATION_URI + || variation == InputType.TYPE_TEXT_VARIATION_FILTER) { + // Our predictions are not useful for e-mail addresses + // or URIs. + mPredictionOn = false; + } - } else if (currentKeyboard == mSymbolsKeyboard) { - mSymbolsKeyboard.setShifted(true); - mInputView.setKeyboard(mSymbolsShiftedKeyboard); - mSymbolsShiftedKeyboard.setShifted(true); - } else if (currentKeyboard == mSymbolsShiftedKeyboard) { - mSymbolsShiftedKeyboard.setShifted(false); - mInputView.setKeyboard(mSymbolsKeyboard); - mSymbolsKeyboard.setShifted(false); - } - } - - private void handleCharacter(int primaryCode, int[] keyCodes) { - if (isInputViewShown()) { - if (mInputView.isShifted()) { - primaryCode = Character.toUpperCase(primaryCode); - } - } - if (isAlphabet(primaryCode) && mPredictionOn) { - mComposing.append((char) primaryCode); - getCurrentInputConnection().setComposingText(mComposing, 1); - updateShiftKeyState(getCurrentInputEditorInfo()); - updateCandidates(); - } else { - getCurrentInputConnection().commitText( - String.valueOf((char) primaryCode), 1); - } - } + if ((attribute.inputType & InputType.TYPE_TEXT_FLAG_AUTO_COMPLETE) != 0) { + // If this is an auto-complete text view, then our predictions + // will not be shown and instead we will allow the editor + // to supply their own. We only show the editor's + // candidates when in fullscreen mode, otherwise relying + // own it displaying its own UI. + mPredictionOn = false; + mCompletionOn = isFullscreenMode(); + } - private void handleClose() { - commitTyped(getCurrentInputConnection()); - requestHideSelf(0); - mInputView.closing(); - } + // We also want to look at the current state of the editor + // to decide whether our alphabetic keyboard should start out + // shifted. + updateShiftKeyState(attribute); + break; - private void checkToggleCapsLock() { - long now = System.currentTimeMillis(); - if (mLastShiftTime + 800 > now) { - mCapsLock = !mCapsLock; - mLastShiftTime = 0; - } else { - mLastShiftTime = now; - } - } - - private String getWordSeparators() { - return mWordSeparators; - } - - public boolean isWordSeparator(int code) { - String separators = getWordSeparators(); - return separators.contains(String.valueOf((char)code)); - } + default: + // For all unknown input types, default to the alphabetic + // keyboard with no special features. + mCurKeyboard = mQwertyKeyboard; + updateShiftKeyState(attribute); + } - public void pickDefaultCandidate() { - pickSuggestionManually(0); - } - - public void pickSuggestionManually(int index) { - if (mCompletionOn && mCompletions != null && index >= 0 - && index < mCompletions.length) { - CompletionInfo ci = mCompletions[index]; - getCurrentInputConnection().commitCompletion(ci); - if (mCandidateView != null) { - mCandidateView.clear(); - } - updateShiftKeyState(getCurrentInputEditorInfo()); - } else if (mComposing.length() > 0) { - // If we were generating candidate suggestions for the current - // text, we would commit one of them here. But for this sample, - // we will just commit the current text. - commitTyped(getCurrentInputConnection()); - } - } - - public void swipeRight() { - if (mCompletionOn) { - pickDefaultCandidate(); - } - } - - public void swipeLeft() { - handleBackspace(); - } + // Update the label on the enter key, depending on what the application + // says it will do. + mCurKeyboard.setImeOptions(getResources(), attribute.imeOptions); + } - public void swipeDown() { - handleClose(); - } + /** + * This is called when the user is done editing a field. We can use this to + * reset our state. + */ + @Override + public void onFinishInput() { + super.onFinishInput(); - public void swipeUp() { - } - - public void onPress(int primaryCode) { - } - - public void onRelease(int primaryCode) { - } + // Clear current composing text and candidates. + mComposing.setLength(0); + updateCandidates(); + + // We only hide the candidates window when finishing input on + // a particular editor, to avoid popping the underlying application + // up and down if the user is entering text into the bottom of + // its window. + setCandidatesViewShown(false); + + mCurKeyboard = mQwertyKeyboard; + if (mInputView != null) { + mInputView.closing(); + } + } + + @Override + public void onStartInputView(EditorInfo attribute, boolean restarting) { + super.onStartInputView(attribute, restarting); + // Apply the selected keyboard to the input view. + mInputView.setKeyboard(mCurKeyboard); + mInputView.closing(); + // final InputMethodSubtype subtype = + // mInputMethodManager.getCurrentInputMethodSubtype(); + // mInputView.setSubtypeOnSpaceKey(subtype); + } + + @Override + public void onCurrentInputMethodSubtypeChanged(InputMethodSubtype subtype) { + mInputView.setSubtypeOnSpaceKey(subtype); + } + + /** + * Deal with the editor reporting movement of its cursor. + */ + @Override + public void onUpdateSelection(int oldSelStart, int oldSelEnd, + int newSelStart, int newSelEnd, int candidatesStart, + int candidatesEnd) { + super.onUpdateSelection(oldSelStart, oldSelEnd, newSelStart, newSelEnd, + candidatesStart, candidatesEnd); + + // If the current selection in the text view changes, we should + // clear whatever candidate text we have. + if (mComposing.length() > 0 + && (newSelStart != candidatesEnd || newSelEnd != candidatesEnd)) { + mComposing.setLength(0); + updateCandidates(); + InputConnection ic = getCurrentInputConnection(); + if (ic != null) { + ic.finishComposingText(); + } + } + } + + /** + * This tells us about completions that the editor has determined based on + * the current text in it. We want to use this in fullscreen mode to show + * the completions ourself, since the editor can not be seen in that + * situation. + */ + @Override + public void onDisplayCompletions(CompletionInfo[] completions) { + if (mCompletionOn) { + mCompletions = completions; + if (completions == null) { + setSuggestions(null, false, false); + return; + } + + List stringList = new ArrayList(); + for (int i = 0; i < completions.length; i++) { + CompletionInfo ci = completions[i]; + if (ci != null) + stringList.add(ci.getText().toString()); + } + setSuggestions(stringList, true, true); + } + } + + /** + * Use this to monitor key events being delivered to the application. We get + * first crack at them, and can either resume them or let them continue to + * the app. + */ + @Override + public boolean onKeyDown(int keyCode, KeyEvent event) { + switch (keyCode) { + case KeyEvent.KEYCODE_BACK: + // The InputMethodService already takes care of the back + // key for us, to dismiss the input method if it is shown. + // However, our keyboard could be showing a pop-up window + // that back should dismiss, so we first allow it to do that. + if (event.getRepeatCount() == 0 && mInputView != null) { + if (mInputView.handleBack()) { + return true; + } + } + break; + + case KeyEvent.KEYCODE_DEL: + // Special handling of the delete key: if we currently are + // composing text for the user, we want to modify that instead + // of let the application to the delete itself. + if (mComposing.length() > 0) { + onKey(Keyboard.KEYCODE_DELETE, null); + return true; + } + break; + + case KeyEvent.KEYCODE_ENTER: + // Let the underlying text editor always handle these. + return false; + + default: + + } + + return super.onKeyDown(keyCode, event); + } + + /** + * Helper function to commit any text being composed in to the editor. + */ + private void commitTyped(InputConnection inputConnection) { + if (mComposing.length() > 0) { + inputConnection.commitText(mComposing, mComposing.length()); + mComposing.setLength(0); + updateCandidates(); + } + } + + /** + * Helper to update the shift state of our keyboard based on the initial + * editor state. + */ + private void updateShiftKeyState(EditorInfo attr) { + if (attr != null && mInputView != null + && mQwertyKeyboard == mInputView.getKeyboard()) { + int caps = 0; + EditorInfo ei = getCurrentInputEditorInfo(); + if (ei != null && ei.inputType != InputType.TYPE_NULL) { + caps = getCurrentInputConnection().getCursorCapsMode( + attr.inputType); + } + mInputView.setShifted(mCapsLock || caps != 0); + } + } + + /** + * Helper to determine if a given character code is alphabetic. + */ + private boolean isAlphabet(int code) { + if (Character.isLetter(code)) { + return true; + } else { + return false; + } + } + + /** + * Helper to send a key down / key up pair to the current editor. + */ + private void keyDownUp(int keyEventCode) { + getCurrentInputConnection().sendKeyEvent( + new KeyEvent(KeyEvent.ACTION_DOWN, keyEventCode)); + getCurrentInputConnection().sendKeyEvent( + new KeyEvent(KeyEvent.ACTION_UP, keyEventCode)); + } + + /** + * Helper to send a character to the editor as raw key events. + */ + private void sendKey(int keyCode) { + switch (keyCode) { + case '\n': + keyDownUp(KeyEvent.KEYCODE_ENTER); + break; + default: + if (keyCode >= '0' && keyCode <= '9') { + keyDownUp(keyCode - '0' + KeyEvent.KEYCODE_0); + } else { + getCurrentInputConnection().commitText( + String.valueOf((char) keyCode), 1); + } + break; + } + } + + // Implementation of KeyboardViewListener + + public void onKey(int primaryCode, int[] keyCodes) { + if (isWordSeparator(primaryCode)) { + // Handle separator + if (mComposing.length() > 0) { + commitTyped(getCurrentInputConnection()); + } + sendKey(primaryCode); + updateShiftKeyState(getCurrentInputEditorInfo()); + } else if (primaryCode == Keyboard.KEYCODE_DELETE) { + android.util.Log.d("DEBUG", "DELETE"); + handleBackspace(); + } else if (primaryCode == Keyboard.KEYCODE_SHIFT) { + android.util.Log.d("DEBUG", "SHIFT"); + handleShift(); + } else if (primaryCode == Keyboard.KEYCODE_CANCEL) { + android.util.Log.d("DEBUG", "CANCEL"); + handleClose(); + return; + } else if (primaryCode == LatinKeyboardView.KEYCODE_KP2A) { + + AlertDialog.Builder builder = new AlertDialog.Builder(this); + String title = "Keepass2Android"; + HashMap availableFields = keepass2android.kbbridge.KeyboardData.availableFields; + + final ArrayList items = new ArrayList(); + final ArrayList values = new ArrayList(); + for (HashMap.Entry entry : availableFields.entrySet()) + { + String key = entry.getKey(); + String value = entry.getValue(); + items.add(key); + values.add(value); + } + + + if (keepass2android.kbbridge.KeyboardData.entryName == null) + { + items.add(getString(R.string.open_entry)); + values.add(""); + } + else + { + title += " ("+keepass2android.kbbridge.KeyboardData.entryName+")"; + items.add(getString(R.string.change_entry)); + values.add(""); + } + builder.setTitle(title); + + // builder.setMessage("What do you want to type securely?"); + builder.setItems(items.toArray(new CharSequence[items.size()]), + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int item) { + + if (item == items.size() - 1) { + //change entry + Intent startKp2aIntent = getPackageManager().getLaunchIntentForPackage(getApplicationContext().getPackageName()); + if (startKp2aIntent != null) + { + startKp2aIntent.addCategory(Intent.CATEGORY_LAUNCHER); + startKp2aIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + startActivity(startKp2aIntent); + Settings.Secure.getString( + getContentResolver(), + Settings.Secure.DEFAULT_INPUT_METHOD + ); + } + } else { + getCurrentInputConnection().commitText( + values.get(item), 0); + } + } + }); + + builder.setNegativeButton(android.R.string.cancel, + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + // User cancelled the dialog + } + }); + + // Create the AlertDialog + AlertDialog dialog = builder.create(); + Window window = dialog.getWindow(); + WindowManager.LayoutParams lp = window.getAttributes(); + lp.token = mInputView.getWindowToken(); + lp.type = WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG; + window.setAttributes(lp); + window.addFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); + + dialog.show(); + } else if (primaryCode == LatinKeyboardView.KEYCODE_SELECT_IME) { + mInputMethodManager.showInputMethodPicker(); + } else if (primaryCode == Keyboard.KEYCODE_MODE_CHANGE + && mInputView != null) { + Keyboard current = mInputView.getKeyboard(); + if (current == mSymbolsKeyboard + || current == mSymbolsShiftedKeyboard) { + current = mQwertyKeyboard; + } else { + current = mSymbolsKeyboard; + } + mInputView.setKeyboard(current); + if (current == mSymbolsKeyboard) { + current.setShifted(false); + } + } else { + handleCharacter(primaryCode, keyCodes); + // mCapsLock = false; + // mInputView.setShifted(mCapsLock); + updateShiftKeyState(getCurrentInputEditorInfo()); + } + } + + public void onText(CharSequence text) { + InputConnection ic = getCurrentInputConnection(); + if (ic == null) + return; + ic.beginBatchEdit(); + if (mComposing.length() > 0) { + commitTyped(ic); + } + ic.commitText(text, 0); + ic.endBatchEdit(); + updateShiftKeyState(getCurrentInputEditorInfo()); + } + + /** + * Update the list of available candidates from the current composing text. + * This will need to be filled in by however you are determining candidates. + */ + private void updateCandidates() { + if (!mCompletionOn) { + if (mComposing.length() > 0) { + ArrayList list = new ArrayList(); + list.add(mComposing.toString()); + setSuggestions(list, true, true); + } else { + setSuggestions(null, false, false); + } + } + } + + public void setSuggestions(List suggestions, boolean completions, + boolean typedWordValid) { + if (suggestions != null && suggestions.size() > 0) { + setCandidatesViewShown(true); + } else if (isExtractViewShown()) { + setCandidatesViewShown(true); + } + if (mCandidateView != null) { + mCandidateView.setSuggestions(suggestions, completions, + typedWordValid); + } + } + + private void handleBackspace() { + final int length = mComposing.length(); + if (length > 1) { + mComposing.delete(length - 1, length); + getCurrentInputConnection().setComposingText(mComposing, 1); + updateCandidates(); + } else if (length > 0) { + mComposing.setLength(0); + getCurrentInputConnection().commitText("", 0); + updateCandidates(); + } else { + keyDownUp(KeyEvent.KEYCODE_DEL); + } + updateShiftKeyState(getCurrentInputEditorInfo()); + } + + private void handleShift() { + if (mInputView == null) { + return; + } + + Keyboard currentKeyboard = mInputView.getKeyboard(); + if (mQwertyKeyboard == currentKeyboard) { + // Alphabet keyboard + checkToggleCapsLock(); + mInputView.setShifted(mCapsLock || !mInputView.isShifted()); + + } else if (currentKeyboard == mSymbolsKeyboard) { + mSymbolsKeyboard.setShifted(true); + mInputView.setKeyboard(mSymbolsShiftedKeyboard); + mSymbolsShiftedKeyboard.setShifted(true); + } else if (currentKeyboard == mSymbolsShiftedKeyboard) { + mSymbolsShiftedKeyboard.setShifted(false); + mInputView.setKeyboard(mSymbolsKeyboard); + mSymbolsKeyboard.setShifted(false); + } + } + + private void handleCharacter(int primaryCode, int[] keyCodes) { + if (isInputViewShown()) { + if (mInputView.isShifted()) { + primaryCode = Character.toUpperCase(primaryCode); + } + } + if (isAlphabet(primaryCode) && mPredictionOn) { + mComposing.append((char) primaryCode); + getCurrentInputConnection().setComposingText(mComposing, 1); + updateShiftKeyState(getCurrentInputEditorInfo()); + updateCandidates(); + } else { + getCurrentInputConnection().commitText( + String.valueOf((char) primaryCode), 1); + } + } + + private void handleClose() { + commitTyped(getCurrentInputConnection()); + requestHideSelf(0); + mInputView.closing(); + } + + private void checkToggleCapsLock() { + long now = System.currentTimeMillis(); + if (mLastShiftTime + 800 > now) { + mCapsLock = !mCapsLock; + mLastShiftTime = 0; + } else { + mLastShiftTime = now; + } + } + + private String getWordSeparators() { + return mWordSeparators; + } + + public boolean isWordSeparator(int code) { + String separators = getWordSeparators(); + return separators.contains(String.valueOf((char) code)); + } + + public void pickDefaultCandidate() { + pickSuggestionManually(0); + } + + public void pickSuggestionManually(int index) { + if (mCompletionOn && mCompletions != null && index >= 0 + && index < mCompletions.length) { + CompletionInfo ci = mCompletions[index]; + getCurrentInputConnection().commitCompletion(ci); + if (mCandidateView != null) { + mCandidateView.clear(); + } + updateShiftKeyState(getCurrentInputEditorInfo()); + } else if (mComposing.length() > 0) { + // If we were generating candidate suggestions for the current + // text, we would commit one of them here. But for this sample, + // we will just commit the current text. + commitTyped(getCurrentInputConnection()); + } + } + + public void swipeRight() { + if (mCompletionOn) { + pickDefaultCandidate(); + } + } + + public void swipeLeft() { + handleBackspace(); + } + + public void swipeDown() { + handleClose(); + } + + public void swipeUp() { + } + + public void onPress(int primaryCode) { + } + + public void onRelease(int primaryCode) { + } } diff --git a/src/java/KP2ASoftKeyboard/src/keepass2android/softkeyboard/LatinKeyboardView.java b/src/java/KP2ASoftKeyboard/src/keepass2android/softkeyboard/LatinKeyboardView.java index c91200c2..a1854da8 100644 --- a/src/java/KP2ASoftKeyboard/src/keepass2android/softkeyboard/LatinKeyboardView.java +++ b/src/java/KP2ASoftKeyboard/src/keepass2android/softkeyboard/LatinKeyboardView.java @@ -27,11 +27,12 @@ public class LatinKeyboardView extends KeyboardView { static final int KEYCODE_OPTIONS = -100; static final int KEYCODE_KP2A = -101; + static final int KEYCODE_SELECT_IME = -102; public LatinKeyboardView(Context context, AttributeSet attrs) { super(context, attrs); } - + public LatinKeyboardView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } diff --git a/src/java/kbbridge/.classpath b/src/java/kbbridge/.classpath deleted file mode 100644 index a4763d1e..00000000 --- a/src/java/kbbridge/.classpath +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - diff --git a/src/java/kbbridge/.project b/src/java/kbbridge/.project deleted file mode 100644 index 51dabebc..00000000 --- a/src/java/kbbridge/.project +++ /dev/null @@ -1,33 +0,0 @@ - - - KP2ASoftKeyboardBridge - - - - - - com.android.ide.eclipse.adt.ResourceManagerBuilder - - - - - com.android.ide.eclipse.adt.PreCompilerBuilder - - - - - org.eclipse.jdt.core.javabuilder - - - - - com.android.ide.eclipse.adt.ApkBuilder - - - - - - com.android.ide.eclipse.adt.AndroidNature - org.eclipse.jdt.core.javanature - - diff --git a/src/java/kbbridge/AndroidManifest.xml b/src/java/kbbridge/AndroidManifest.xml deleted file mode 100644 index 1f0ec938..00000000 --- a/src/java/kbbridge/AndroidManifest.xml +++ /dev/null @@ -1,17 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/src/java/kbbridge/gen/keepass2android/kbbridge/BuildConfig.java b/src/java/kbbridge/gen/keepass2android/kbbridge/BuildConfig.java deleted file mode 100644 index a853a376..00000000 --- a/src/java/kbbridge/gen/keepass2android/kbbridge/BuildConfig.java +++ /dev/null @@ -1,6 +0,0 @@ -/** Automatically generated file. DO NOT MODIFY */ -package keepass2android.kbbridge; - -public final class BuildConfig { - public final static boolean DEBUG = true; -} \ No newline at end of file diff --git a/src/java/kbbridge/gen/keepass2android/kbbridge/R.java b/src/java/kbbridge/gen/keepass2android/kbbridge/R.java deleted file mode 100644 index 376d8ace..00000000 --- a/src/java/kbbridge/gen/keepass2android/kbbridge/R.java +++ /dev/null @@ -1,47 +0,0 @@ -/* AUTO-GENERATED FILE. DO NOT MODIFY. - * - * This class was automatically generated by the - * aapt tool from the resource data it found. It - * should not be modified by hand. - */ - -package keepass2android.kbbridge; - -public final class R { - public static final class attr { - } - public static final class drawable { - public static int ic_launcher=0x7f020000; - } - public static final class string { - public static int app_name=0x7f030000; - } - public static final class style { - /** - Base application theme, dependent on API level. This theme is replaced - by AppBaseTheme from res/values-vXX/styles.xml on newer devices. - - - Theme customizations available in newer API levels can go in - res/values-vXX/styles.xml, while customizations related to - backward-compatibility can go here. - - - Base application theme for API 11+. This theme completely replaces - AppBaseTheme from res/values/styles.xml on API 11+ devices. - - API 11 theme customizations can go here. - - Base application theme for API 14+. This theme completely replaces - AppBaseTheme from BOTH res/values/styles.xml and - res/values-v11/styles.xml on API 14+ devices. - - API 14 theme customizations can go here. - */ - public static int AppBaseTheme=0x7f040000; - /** Application theme. - All customizations that are NOT specific to a particular API-level can go here. - */ - public static int AppTheme=0x7f040001; - } -} diff --git a/src/java/kbbridge/proguard-project.txt b/src/java/kbbridge/proguard-project.txt deleted file mode 100644 index f2fe1559..00000000 --- a/src/java/kbbridge/proguard-project.txt +++ /dev/null @@ -1,20 +0,0 @@ -# To enable ProGuard in your project, edit project.properties -# to define the proguard.config property as described in that file. -# -# Add project specific ProGuard rules here. -# By default, the flags in this file are appended to flags specified -# in ${sdk.dir}/tools/proguard/proguard-android.txt -# You can edit the include path and order by changing the ProGuard -# include property in project.properties. -# -# For more details, see -# http://developer.android.com/guide/developing/tools/proguard.html - -# Add any project specific keep options here: - -# If your project uses WebView with JS, uncomment the following -# and specify the fully qualified class name to the JavaScript interface -# class: -#-keepclassmembers class fqcn.of.javascript.interface.for.webview { -# public *; -#} diff --git a/src/java/kbbridge/project.properties b/src/java/kbbridge/project.properties deleted file mode 100644 index 22e1c480..00000000 --- a/src/java/kbbridge/project.properties +++ /dev/null @@ -1,15 +0,0 @@ -# This file is automatically generated by Android Tools. -# Do not modify this file -- YOUR CHANGES WILL BE ERASED! -# -# This file must be checked in Version Control Systems. -# -# To customize properties used by the Ant build system edit -# "ant.properties", and override values to adapt the script to your -# project structure. -# -# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home): -#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt - -# Project target. -target=android-14 -android.library=true diff --git a/src/java/kbbridge/res/values/strings.xml b/src/java/kbbridge/res/values/strings.xml deleted file mode 100644 index 2312da05..00000000 --- a/src/java/kbbridge/res/values/strings.xml +++ /dev/null @@ -1,5 +0,0 @@ - - - KP2ASoftKeyboardBridge - - \ No newline at end of file diff --git a/src/java/kbbridge/res/values/styles.xml b/src/java/kbbridge/res/values/styles.xml deleted file mode 100644 index 4a10ca49..00000000 --- a/src/java/kbbridge/res/values/styles.xml +++ /dev/null @@ -1,20 +0,0 @@ - - - - - - - - - \ No newline at end of file diff --git a/src/java/kbbridge/src/keepass2android/kbbridge/KeyboardData.java b/src/java/kbbridge/src/keepass2android/kbbridge/KeyboardData.java deleted file mode 100644 index 4538f6b6..00000000 --- a/src/java/kbbridge/src/keepass2android/kbbridge/KeyboardData.java +++ /dev/null @@ -1,6 +0,0 @@ - -package keepass2android.kbbridge; -import java.util.HashMap; -public class KeyboardData { - public static HashMap availableFields = new HashMap(); -} diff --git a/src/keepass2android/Properties/AndroidManifest_net.xml b/src/keepass2android/Properties/AndroidManifest_net.xml index fb07a999..069f6fc0 100644 --- a/src/keepass2android/Properties/AndroidManifest_net.xml +++ b/src/keepass2android/Properties/AndroidManifest_net.xml @@ -25,6 +25,14 @@ + + + + + + + diff --git a/src/keepass2android/Resources/Resource.designer.cs b/src/keepass2android/Resources/Resource.designer.cs index d19e7e8d..53e96319 100644 --- a/src/keepass2android/Resources/Resource.designer.cs +++ b/src/keepass2android/Resources/Resource.designer.cs @@ -27,20 +27,20 @@ namespace keepass2android public partial class Array { - // aapt resource value: 0x7f080002 - public const int clipboard_timeout_options = 2131230722; + // aapt resource value: 0x7f090002 + public const int clipboard_timeout_options = 2131296258; - // aapt resource value: 0x7f080000 - public const int clipboard_timeout_values = 2131230720; + // aapt resource value: 0x7f090000 + public const int clipboard_timeout_values = 2131296256; - // aapt resource value: 0x7f080004 - public const int cred_remember_modes = 2131230724; + // aapt resource value: 0x7f090004 + public const int cred_remember_modes = 2131296260; - // aapt resource value: 0x7f080003 - public const int list_size_options = 2131230723; + // aapt resource value: 0x7f090003 + public const int list_size_options = 2131296259; - // aapt resource value: 0x7f080001 - public const int list_size_values = 2131230721; + // aapt resource value: 0x7f090001 + public const int list_size_values = 2131296257; private Array() { @@ -58,20 +58,20 @@ namespace keepass2android public partial class Boolean { - // aapt resource value: 0x7f070004 - public const int TanExpiresOnUse_default = 2131165188; + // aapt resource value: 0x7f080004 + public const int TanExpiresOnUse_default = 2131230724; - // aapt resource value: 0x7f070001 - public const int keyfile_default = 2131165185; + // aapt resource value: 0x7f080001 + public const int keyfile_default = 2131230721; - // aapt resource value: 0x7f070000 - public const int maskpass_default = 2131165184; + // aapt resource value: 0x7f080000 + public const int maskpass_default = 2131230720; - // aapt resource value: 0x7f070003 - public const int omitbackup_default = 2131165187; + // aapt resource value: 0x7f080003 + public const int omitbackup_default = 2131230723; - // aapt resource value: 0x7f070002 - public const int sort_default = 2131165186; + // aapt resource value: 0x7f080002 + public const int sort_default = 2131230722; private Boolean() { @@ -81,35 +81,64 @@ namespace keepass2android public partial class Color { - // aapt resource value: 0x7f050007 - public const int bg_gray = 2131034119; - - // aapt resource value: 0x7f050000 - public const int blue_highlight = 2131034112; - - // aapt resource value: 0x7f050005 - public const int emphasis = 2131034117; - - // aapt resource value: 0x7f050006 - public const int emphasis2 = 2131034118; - - // aapt resource value: 0x7f050001 - public const int group = 2131034113; + // aapt resource value: 0x7f05000b + public const int bg_gray = 2131034123; // aapt resource value: 0x7f050004 - public const int group_header_button_pressed = 2131034116; - - // aapt resource value: 0x7f050002 - public const int icon_background = 2131034114; + public const int blue_highlight = 2131034116; // aapt resource value: 0x7f050003 - public const int icon_text = 2131034115; + public const int candidate_background = 2131034115; + + // aapt resource value: 0x7f050000 + public const int candidate_normal = 2131034112; + + // aapt resource value: 0x7f050002 + public const int candidate_other = 2131034114; + + // aapt resource value: 0x7f050001 + public const int candidate_recommended = 2131034113; + + // aapt resource value: 0x7f050009 + public const int emphasis = 2131034121; + + // aapt resource value: 0x7f05000a + public const int emphasis2 = 2131034122; + + // aapt resource value: 0x7f050005 + public const int group = 2131034117; + + // aapt resource value: 0x7f050008 + public const int group_header_button_pressed = 2131034120; + + // aapt resource value: 0x7f050006 + public const int icon_background = 2131034118; + + // aapt resource value: 0x7f050007 + public const int icon_text = 2131034119; private Color() { } } + public partial class Dimension + { + + // aapt resource value: 0x7f060001 + public const int candidate_font_height = 2131099649; + + // aapt resource value: 0x7f060002 + public const int candidate_vertical_padding = 2131099650; + + // aapt resource value: 0x7f060000 + public const int key_height = 2131099648; + + private Dimension() + { + } + } + public partial class Drawable { @@ -384,13 +413,40 @@ namespace keepass2android public const int notify = 2130837593; // aapt resource value: 0x7f02005a - public const int RedButton = 2130837594; + public const int notify_keyboard = 2130837594; // aapt resource value: 0x7f02005b - public const int section_header = 2130837595; + public const int RedButton = 2130837595; // aapt resource value: 0x7f02005c - public const int YellowButton = 2130837596; + public const int section_header = 2130837596; + + // aapt resource value: 0x7f02005d + public const int sym_keyboard = 2130837597; + + // aapt resource value: 0x7f02005e + public const int sym_keyboard_delete = 2130837598; + + // aapt resource value: 0x7f02005f + public const int sym_keyboard_done = 2130837599; + + // aapt resource value: 0x7f020060 + public const int sym_keyboard_kp2a = 2130837600; + + // aapt resource value: 0x7f020061 + public const int sym_keyboard_return = 2130837601; + + // aapt resource value: 0x7f020062 + public const int sym_keyboard_search = 2130837602; + + // aapt resource value: 0x7f020063 + public const int sym_keyboard_shift = 2130837603; + + // aapt resource value: 0x7f020064 + public const int sym_keyboard_space = 2130837604; + + // aapt resource value: 0x7f020065 + public const int YellowButton = 2130837605; private Drawable() { @@ -400,491 +456,494 @@ namespace keepass2android public partial class Id { - // aapt resource value: 0x7f0b000a - public const int Credit = 2131427338; + // aapt resource value: 0x7f0c000a + public const int Credit = 2131492874; - // aapt resource value: 0x7f0b0070 - public const int IconGridView = 2131427440; + // aapt resource value: 0x7f0c0070 + public const int IconGridView = 2131492976; - // aapt resource value: 0x7f0b007d - public const int QuickUnlock_button = 2131427453; + // aapt resource value: 0x7f0c007e + public const int QuickUnlock_button = 2131492990; - // aapt resource value: 0x7f0b007e - public const int QuickUnlock_buttonLock = 2131427454; + // aapt resource value: 0x7f0c007f + public const int QuickUnlock_buttonLock = 2131492991; - // aapt resource value: 0x7f0b007b - public const int QuickUnlock_label = 2131427451; + // aapt resource value: 0x7f0c007c + public const int QuickUnlock_label = 2131492988; - // aapt resource value: 0x7f0b007c - public const int QuickUnlock_password = 2131427452; + // aapt resource value: 0x7f0c007d + public const int QuickUnlock_password = 2131492989; - // aapt resource value: 0x7f0b0054 - public const int RelativeLayout = 2131427412; + // aapt resource value: 0x7f0c0054 + public const int RelativeLayout = 2131492948; - // aapt resource value: 0x7f0b0053 - public const int ScrollView = 2131427411; + // aapt resource value: 0x7f0c0053 + public const int ScrollView = 2131492947; - // aapt resource value: 0x7f0b0009 - public const int about_button = 2131427337; + // aapt resource value: 0x7f0c0009 + public const int about_button = 2131492873; - // aapt resource value: 0x7f0b0000 - public const int about_title = 2131427328; + // aapt resource value: 0x7f0c0000 + public const int about_title = 2131492864; - // aapt resource value: 0x7f0b0051 - public const int accept_button = 2131427409; + // aapt resource value: 0x7f0c0051 + public const int accept_button = 2131492945; - // aapt resource value: 0x7f0b0024 - public const int add_advanced = 2131427364; + // aapt resource value: 0x7f0c0024 + public const int add_advanced = 2131492900; - // aapt resource value: 0x7f0b0067 - public const int add_entry = 2131427431; + // aapt resource value: 0x7f0c0067 + public const int add_entry = 2131492967; - // aapt resource value: 0x7f0b0066 - public const int add_group = 2131427430; + // aapt resource value: 0x7f0c0066 + public const int add_group = 2131492966; - // aapt resource value: 0x7f0b0023 - public const int advanced_container = 2131427363; + // aapt resource value: 0x7f0c0023 + public const int advanced_container = 2131492899; - // aapt resource value: 0x7f0b0026 - public const int binaries = 2131427366; + // aapt resource value: 0x7f0c0026 + public const int binaries = 2131492902; - // aapt resource value: 0x7f0b0036 - public const int bottom_bar = 2131427382; + // aapt resource value: 0x7f0c0036 + public const int bottom_bar = 2131492918; - // aapt resource value: 0x7f0b0050 - public const int bottom_layout = 2131427408; + // aapt resource value: 0x7f0c0050 + public const int bottom_layout = 2131492944; - // aapt resource value: 0x7f0b0048 - public const int browse_button = 2131427400; + // aapt resource value: 0x7f0c0048 + public const int browse_button = 2131492936; - // aapt resource value: 0x7f0b0059 - public const int btn_length12 = 2131427417; + // aapt resource value: 0x7f0c0059 + public const int btn_length12 = 2131492953; - // aapt resource value: 0x7f0b0058 - public const int btn_length16 = 2131427416; + // aapt resource value: 0x7f0c0058 + public const int btn_length16 = 2131492952; - // aapt resource value: 0x7f0b005b - public const int btn_length6 = 2131427419; + // aapt resource value: 0x7f0c005b + public const int btn_length6 = 2131492955; - // aapt resource value: 0x7f0b005a - public const int btn_length8 = 2131427418; + // aapt resource value: 0x7f0c005a + public const int btn_length8 = 2131492954; - // aapt resource value: 0x7f0b000e - public const int cancel = 2131427342; + // aapt resource value: 0x7f0c000e + public const int cancel = 2131492878; - // aapt resource value: 0x7f0b0052 - public const int cancel_button = 2131427410; + // aapt resource value: 0x7f0c0052 + public const int cancel_button = 2131492946; - // aapt resource value: 0x7f0b008e - public const int cbCaseSensitive = 2131427470; + // aapt resource value: 0x7f0c008f + public const int cbCaseSensitive = 2131493007; - // aapt resource value: 0x7f0b008f - public const int cbExcludeExpiredEntries = 2131427471; + // aapt resource value: 0x7f0c0090 + public const int cbExcludeExpiredEntries = 2131493008; - // aapt resource value: 0x7f0b0084 - public const int cbRegEx = 2131427460; + // aapt resource value: 0x7f0c0085 + public const int cbRegEx = 2131492997; - // aapt resource value: 0x7f0b008d - public const int cbSearchInGroupName = 2131427469; + // aapt resource value: 0x7f0c008e + public const int cbSearchInGroupName = 2131493006; - // aapt resource value: 0x7f0b008a - public const int cbSearchInNotes = 2131427466; + // aapt resource value: 0x7f0c008b + public const int cbSearchInNotes = 2131493003; - // aapt resource value: 0x7f0b008b - public const int cbSearchInOtherStrings = 2131427467; + // aapt resource value: 0x7f0c008c + public const int cbSearchInOtherStrings = 2131493004; - // aapt resource value: 0x7f0b0089 - public const int cbSearchInPassword = 2131427465; + // aapt resource value: 0x7f0c008a + public const int cbSearchInPassword = 2131493002; - // aapt resource value: 0x7f0b008c - public const int cbSearchInTags = 2131427468; + // aapt resource value: 0x7f0c008d + public const int cbSearchInTags = 2131493005; - // aapt resource value: 0x7f0b0086 - public const int cbSearchInTitle = 2131427462; + // aapt resource value: 0x7f0c0087 + public const int cbSearchInTitle = 2131492999; - // aapt resource value: 0x7f0b0087 - public const int cbSearchInUrl = 2131427463; + // aapt resource value: 0x7f0c0088 + public const int cbSearchInUrl = 2131493000; - // aapt resource value: 0x7f0b0088 - public const int cbSearchInUsername = 2131427464; + // aapt resource value: 0x7f0c0089 + public const int cbSearchInUsername = 2131493001; - // aapt resource value: 0x7f0b0064 - public const int cb_brackets = 2131427428; + // aapt resource value: 0x7f0c0064 + public const int cb_brackets = 2131492964; - // aapt resource value: 0x7f0b005f - public const int cb_digits = 2131427423; + // aapt resource value: 0x7f0c005f + public const int cb_digits = 2131492959; - // aapt resource value: 0x7f0b005e - public const int cb_lowercase = 2131427422; + // aapt resource value: 0x7f0c005e + public const int cb_lowercase = 2131492958; - // aapt resource value: 0x7f0b0060 - public const int cb_minus = 2131427424; + // aapt resource value: 0x7f0c0060 + public const int cb_minus = 2131492960; - // aapt resource value: 0x7f0b0062 - public const int cb_space = 2131427426; + // aapt resource value: 0x7f0c0062 + public const int cb_space = 2131492962; - // aapt resource value: 0x7f0b0063 - public const int cb_specials = 2131427427; + // aapt resource value: 0x7f0c0063 + public const int cb_specials = 2131492963; - // aapt resource value: 0x7f0b0061 - public const int cb_underline = 2131427425; + // aapt resource value: 0x7f0c0061 + public const int cb_underline = 2131492961; - // aapt resource value: 0x7f0b005d - public const int cb_uppercase = 2131427421; + // aapt resource value: 0x7f0c005d + public const int cb_uppercase = 2131492957; - // aapt resource value: 0x7f0b004b - public const int create = 2131427403; + // aapt resource value: 0x7f0c004b + public const int create = 2131492939; - // aapt resource value: 0x7f0b0094 - public const int cred_password = 2131427476; + // aapt resource value: 0x7f0c0095 + public const int cred_password = 2131493013; - // aapt resource value: 0x7f0b0095 - public const int cred_remember_mode = 2131427477; + // aapt resource value: 0x7f0c0096 + public const int cred_remember_mode = 2131493014; - // aapt resource value: 0x7f0b0093 - public const int cred_username = 2131427475; + // aapt resource value: 0x7f0c0094 + public const int cred_username = 2131493012; - // aapt resource value: 0x7f0b0078 - public const int default_database = 2131427448; + // aapt resource value: 0x7f0c0079 + public const int default_database = 2131492985; - // aapt resource value: 0x7f0b0030 - public const int delete = 2131427376; + // aapt resource value: 0x7f0c0030 + public const int delete = 2131492912; - // aapt resource value: 0x7f0b0008 - public const int disclaimer = 2131427336; + // aapt resource value: 0x7f0c0008 + public const int disclaimer = 2131492872; - // aapt resource value: 0x7f0b0001 - public const int divider1 = 2131427329; + // aapt resource value: 0x7f0c0001 + public const int divider1 = 2131492865; - // aapt resource value: 0x7f0b0004 - public const int divider2 = 2131427332; + // aapt resource value: 0x7f0c0004 + public const int divider2 = 2131492868; - // aapt resource value: 0x7f0b0007 - public const int divider3 = 2131427335; + // aapt resource value: 0x7f0c0007 + public const int divider3 = 2131492871; - // aapt resource value: 0x7f0b0032 - public const int divider_comment = 2131427378; + // aapt resource value: 0x7f0c0032 + public const int divider_comment = 2131492914; - // aapt resource value: 0x7f0b0079 - public const int enable_quickunlock = 2131427449; + // aapt resource value: 0x7f0c007a + public const int enable_quickunlock = 2131492986; - // aapt resource value: 0x7f0b0041 - public const int entry_accessed = 2131427393; + // aapt resource value: 0x7f0c0041 + public const int entry_accessed = 2131492929; - // aapt resource value: 0x7f0b0040 - public const int entry_accessed_label = 2131427392; + // aapt resource value: 0x7f0c0040 + public const int entry_accessed_label = 2131492928; - // aapt resource value: 0x7f0b0025 - public const int entry_binaries_label = 2131427365; + // aapt resource value: 0x7f0c0025 + public const int entry_binaries_label = 2131492901; - // aapt resource value: 0x7f0b0021 - public const int entry_comment = 2131427361; + // aapt resource value: 0x7f0c0021 + public const int entry_comment = 2131492897; - // aapt resource value: 0x7f0b0020 - public const int entry_comment_label = 2131427360; + // aapt resource value: 0x7f0c0020 + public const int entry_comment_label = 2131492896; - // aapt resource value: 0x7f0b001f - public const int entry_confpassword = 2131427359; + // aapt resource value: 0x7f0c001f + public const int entry_confpassword = 2131492895; - // aapt resource value: 0x7f0b001e - public const int entry_confpassword_label = 2131427358; + // aapt resource value: 0x7f0c001e + public const int entry_confpassword_label = 2131492894; - // aapt resource value: 0x7f0b0039 - public const int entry_contents = 2131427385; + // aapt resource value: 0x7f0c0039 + public const int entry_contents = 2131492921; - // aapt resource value: 0x7f0b003d - public const int entry_created = 2131427389; + // aapt resource value: 0x7f0c003d + public const int entry_created = 2131492925; - // aapt resource value: 0x7f0b003c - public const int entry_created_label = 2131427388; + // aapt resource value: 0x7f0c003c + public const int entry_created_label = 2131492924; - // aapt resource value: 0x7f0b0038 - public const int entry_divider2 = 2131427384; + // aapt resource value: 0x7f0c0038 + public const int entry_divider2 = 2131492920; - // aapt resource value: 0x7f0b0037 - public const int entry_edit = 2131427383; + // aapt resource value: 0x7f0c0037 + public const int entry_edit = 2131492919; - // aapt resource value: 0x7f0b002d - public const int entry_expires = 2131427373; + // aapt resource value: 0x7f0c002d + public const int entry_expires = 2131492909; - // aapt resource value: 0x7f0b002c - public const int entry_expires_checkbox = 2131427372; + // aapt resource value: 0x7f0c002c + public const int entry_expires_checkbox = 2131492908; - // aapt resource value: 0x7f0b002b - public const int entry_expires_label = 2131427371; + // aapt resource value: 0x7f0c002b + public const int entry_expires_label = 2131492907; - // aapt resource value: 0x7f0b0022 - public const int entry_extra_strings_label = 2131427362; + // aapt resource value: 0x7f0c0022 + public const int entry_extra_strings_label = 2131492898; - // aapt resource value: 0x7f0b0033 - public const int entry_icon = 2131427379; + // aapt resource value: 0x7f0c0033 + public const int entry_icon = 2131492915; - // aapt resource value: 0x7f0b003f - public const int entry_modified = 2131427391; + // aapt resource value: 0x7f0c003f + public const int entry_modified = 2131492927; - // aapt resource value: 0x7f0b003e - public const int entry_modified_label = 2131427390; + // aapt resource value: 0x7f0c003e + public const int entry_modified_label = 2131492926; - // aapt resource value: 0x7f0b002a - public const int entry_override_url = 2131427370; + // aapt resource value: 0x7f0c002a + public const int entry_override_url = 2131492906; - // aapt resource value: 0x7f0b0029 - public const int entry_override_url_label = 2131427369; + // aapt resource value: 0x7f0c0029 + public const int entry_override_url_label = 2131492905; - // aapt resource value: 0x7f0b001d - public const int entry_password = 2131427357; + // aapt resource value: 0x7f0c001d + public const int entry_password = 2131492893; - // aapt resource value: 0x7f0b001b - public const int entry_password_label = 2131427355; + // aapt resource value: 0x7f0c001b + public const int entry_password_label = 2131492891; - // aapt resource value: 0x7f0b0012 - public const int entry_save = 2131427346; + // aapt resource value: 0x7f0c0012 + public const int entry_save = 2131492882; - // aapt resource value: 0x7f0b0011 - public const int entry_save_header = 2131427345; + // aapt resource value: 0x7f0c0011 + public const int entry_save_header = 2131492881; - // aapt resource value: 0x7f0b0013 - public const int entry_scroll = 2131427347; + // aapt resource value: 0x7f0c0013 + public const int entry_scroll = 2131492883; - // aapt resource value: 0x7f0b003a - public const int entry_table = 2131427386; + // aapt resource value: 0x7f0c003a + public const int entry_table = 2131492922; - // aapt resource value: 0x7f0b0028 - public const int entry_tags = 2131427368; + // aapt resource value: 0x7f0c0028 + public const int entry_tags = 2131492904; - // aapt resource value: 0x7f0b0027 - public const int entry_tags_label = 2131427367; + // aapt resource value: 0x7f0c0027 + public const int entry_tags_label = 2131492903; - // aapt resource value: 0x7f0b0034 - public const int entry_text = 2131427380; + // aapt resource value: 0x7f0c0034 + public const int entry_text = 2131492916; - // aapt resource value: 0x7f0b0016 - public const int entry_title = 2131427350; + // aapt resource value: 0x7f0c0016 + public const int entry_title = 2131492886; - // aapt resource value: 0x7f0b0014 - public const int entry_title_label = 2131427348; + // aapt resource value: 0x7f0c0014 + public const int entry_title_label = 2131492884; - // aapt resource value: 0x7f0b001a - public const int entry_url = 2131427354; + // aapt resource value: 0x7f0c001a + public const int entry_url = 2131492890; - // aapt resource value: 0x7f0b0019 - public const int entry_url_label = 2131427353; + // aapt resource value: 0x7f0c0019 + public const int entry_url_label = 2131492889; - // aapt resource value: 0x7f0b0018 - public const int entry_user_name = 2131427352; + // aapt resource value: 0x7f0c0018 + public const int entry_user_name = 2131492888; - // aapt resource value: 0x7f0b0017 - public const int entry_user_name_label = 2131427351; + // aapt resource value: 0x7f0c0017 + public const int entry_user_name_label = 2131492887; - // aapt resource value: 0x7f0b003b - public const int extra_strings = 2131427387; + // aapt resource value: 0x7f0c003b + public const int extra_strings = 2131492923; - // aapt resource value: 0x7f0b0006 - public const int feedback = 2131427334; + // aapt resource value: 0x7f0c0006 + public const int feedback = 2131492870; - // aapt resource value: 0x7f0b0042 - public const int file_filename = 2131427394; + // aapt resource value: 0x7f0c0042 + public const int file_filename = 2131492930; - // aapt resource value: 0x7f0b0043 - public const int file_listtop = 2131427395; + // aapt resource value: 0x7f0c0043 + public const int file_listtop = 2131492931; - // aapt resource value: 0x7f0b0044 - public const int file_select = 2131427396; + // aapt resource value: 0x7f0c0044 + public const int file_select = 2131492932; - // aapt resource value: 0x7f0b0073 - public const int filename = 2131427443; + // aapt resource value: 0x7f0c0074 + public const int filename = 2131492980; - // aapt resource value: 0x7f0b0045 - public const int filename_form = 2131427397; + // aapt resource value: 0x7f0c0045 + public const int filename_form = 2131492933; - // aapt resource value: 0x7f0b0071 - public const int filename_label = 2131427441; + // aapt resource value: 0x7f0c0072 + public const int filename_label = 2131492978; - // aapt resource value: 0x7f0b0072 - public const int filenamescroll = 2131427442; + // aapt resource value: 0x7f0c0073 + public const int filenamescroll = 2131492979; - // aapt resource value: 0x7f0b004c - public const int fnv_cancel = 2131427404; + // aapt resource value: 0x7f0c004c + public const int fnv_cancel = 2131492940; - // aapt resource value: 0x7f0b001c - public const int generate_button = 2131427356; + // aapt resource value: 0x7f0c001c + public const int generate_button = 2131492892; - // aapt resource value: 0x7f0b0056 - public const int generate_password_button = 2131427414; + // aapt resource value: 0x7f0c0056 + public const int generate_password_button = 2131492950; - // aapt resource value: 0x7f0b0065 - public const int group_header = 2131427429; + // aapt resource value: 0x7f0c0065 + public const int group_header = 2131492965; - // aapt resource value: 0x7f0b006b - public const int group_icon = 2131427435; + // aapt resource value: 0x7f0c006b + public const int group_icon = 2131492971; - // aapt resource value: 0x7f0b006d - public const int group_label = 2131427437; + // aapt resource value: 0x7f0c006d + public const int group_label = 2131492973; - // aapt resource value: 0x7f0b0068 - public const int group_name = 2131427432; + // aapt resource value: 0x7f0c0068 + public const int group_name = 2131492968; - // aapt resource value: 0x7f0b006c - public const int group_text = 2131427436; + // aapt resource value: 0x7f0c006c + public const int group_text = 2131492972; - // aapt resource value: 0x7f0b0005 - public const int homepage = 2131427333; + // aapt resource value: 0x7f0c0005 + public const int homepage = 2131492869; - // aapt resource value: 0x7f0b006a - public const int icon = 2131427434; + // aapt resource value: 0x7f0c006a + public const int icon = 2131492970; - // aapt resource value: 0x7f0b0015 - public const int icon_button = 2131427349; + // aapt resource value: 0x7f0c0015 + public const int icon_button = 2131492885; - // aapt resource value: 0x7f0b006e - public const int icon_image = 2131427438; + // aapt resource value: 0x7f0c006e + public const int icon_image = 2131492974; - // aapt resource value: 0x7f0b006f - public const int icon_text = 2131427439; + // aapt resource value: 0x7f0c006f + public const int icon_text = 2131492975; - // aapt resource value: 0x7f0b000c - public const int install_market = 2131427340; + // aapt resource value: 0x7f0c000c + public const int install_market = 2131492876; - // aapt resource value: 0x7f0b000d - public const int install_web = 2131427341; + // aapt resource value: 0x7f0c000d + public const int install_web = 2131492877; - // aapt resource value: 0x7f0b0047 - public const int label_open_by_filename = 2131427399; + // aapt resource value: 0x7f0c0071 + public const int keyboard = 2131492977; - // aapt resource value: 0x7f0b0049 - public const int label_open_by_filename_details = 2131427401; + // aapt resource value: 0x7f0c0047 + public const int label_open_by_filename = 2131492935; - // aapt resource value: 0x7f0b0046 - public const int label_warning = 2131427398; + // aapt resource value: 0x7f0c0049 + public const int label_open_by_filename_details = 2131492937; - // aapt resource value: 0x7f0b005c - public const int length = 2131427420; + // aapt resource value: 0x7f0c0046 + public const int label_warning = 2131492934; - // aapt resource value: 0x7f0b0057 - public const int length_label = 2131427415; + // aapt resource value: 0x7f0c005c + public const int length = 2131492956; - // aapt resource value: 0x7f0b0083 - public const int linearLayout1 = 2131427459; + // aapt resource value: 0x7f0c0057 + public const int length_label = 2131492951; - // aapt resource value: 0x7f0b009e - public const int menu_about = 2131427486; + // aapt resource value: 0x7f0c0084 + public const int linearLayout1 = 2131492996; - // aapt resource value: 0x7f0b009d - public const int menu_app_settings = 2131427485; + // aapt resource value: 0x7f0c009f + public const int menu_about = 2131493023; - // aapt resource value: 0x7f0b009c - public const int menu_cancel_edit = 2131427484; + // aapt resource value: 0x7f0c009e + public const int menu_app_settings = 2131493022; - // aapt resource value: 0x7f0b00a0 - public const int menu_change_master_key = 2131427488; + // aapt resource value: 0x7f0c009d + public const int menu_cancel_edit = 2131493021; - // aapt resource value: 0x7f0b0097 - public const int menu_goto_url = 2131427479; + // aapt resource value: 0x7f0c00a1 + public const int menu_change_master_key = 2131493025; - // aapt resource value: 0x7f0b0098 - public const int menu_lock = 2131427480; + // aapt resource value: 0x7f0c0098 + public const int menu_goto_url = 2131493016; - // aapt resource value: 0x7f0b009a - public const int menu_rate = 2131427482; + // aapt resource value: 0x7f0c0099 + public const int menu_lock = 2131493017; - // aapt resource value: 0x7f0b009f - public const int menu_search = 2131427487; + // aapt resource value: 0x7f0c009b + public const int menu_rate = 2131493019; - // aapt resource value: 0x7f0b00a1 - public const int menu_sort = 2131427489; + // aapt resource value: 0x7f0c00a0 + public const int menu_search = 2131493024; - // aapt resource value: 0x7f0b0099 - public const int menu_suggest_improvements = 2131427481; + // aapt resource value: 0x7f0c00a2 + public const int menu_sort = 2131493026; - // aapt resource value: 0x7f0b0096 - public const int menu_toggle_pass = 2131427478; + // aapt resource value: 0x7f0c009a + public const int menu_suggest_improvements = 2131493018; - // aapt resource value: 0x7f0b009b - public const int menu_translate = 2131427483; + // aapt resource value: 0x7f0c0097 + public const int menu_toggle_pass = 2131493015; - // aapt resource value: 0x7f0b0069 - public const int ok = 2131427433; + // aapt resource value: 0x7f0c009c + public const int menu_translate = 2131493020; - // aapt resource value: 0x7f0b004a - public const int open = 2131427402; + // aapt resource value: 0x7f0c0069 + public const int ok = 2131492969; - // aapt resource value: 0x7f0b0091 - public const int pass_conf_password = 2131427473; + // aapt resource value: 0x7f0c004a + public const int open = 2131492938; - // aapt resource value: 0x7f0b0076 - public const int pass_keyfile = 2131427446; + // aapt resource value: 0x7f0c0092 + public const int pass_conf_password = 2131493010; - // aapt resource value: 0x7f0b0077 - public const int pass_ok = 2131427447; + // aapt resource value: 0x7f0c0077 + public const int pass_keyfile = 2131492983; - // aapt resource value: 0x7f0b0090 - public const int pass_password = 2131427472; + // aapt resource value: 0x7f0c0078 + public const int pass_ok = 2131492984; - // aapt resource value: 0x7f0b0055 - public const int password = 2131427413; + // aapt resource value: 0x7f0c0091 + public const int pass_password = 2131493009; - // aapt resource value: 0x7f0b0074 - public const int password_label = 2131427444; + // aapt resource value: 0x7f0c0055 + public const int password = 2131492949; - // aapt resource value: 0x7f0b002f - public const int protection = 2131427375; + // aapt resource value: 0x7f0c0075 + public const int password_label = 2131492981; - // aapt resource value: 0x7f0b007a - public const int qu_filename = 2131427450; + // aapt resource value: 0x7f0c002f + public const int protection = 2131492911; - // aapt resource value: 0x7f0b000f - public const int rounds = 2131427343; + // aapt resource value: 0x7f0c007b + public const int qu_filename = 2131492987; - // aapt resource value: 0x7f0b0010 - public const int rounds_explaination = 2131427344; + // aapt resource value: 0x7f0c000f + public const int rounds = 2131492879; - // aapt resource value: 0x7f0b0082 - public const int scrollView1 = 2131427458; + // aapt resource value: 0x7f0c0010 + public const int rounds_explaination = 2131492880; - // aapt resource value: 0x7f0b0081 - public const int searchEditText = 2131427457; + // aapt resource value: 0x7f0c0083 + public const int scrollView1 = 2131492995; - // aapt resource value: 0x7f0b0080 - public const int search_button = 2131427456; + // aapt resource value: 0x7f0c0082 + public const int searchEditText = 2131492994; - // aapt resource value: 0x7f0b0085 - public const int search_in_label = 2131427461; + // aapt resource value: 0x7f0c0081 + public const int search_button = 2131492993; - // aapt resource value: 0x7f0b007f - public const int search_label = 2131427455; + // aapt resource value: 0x7f0c0086 + public const int search_in_label = 2131492998; - // aapt resource value: 0x7f0b004f - public const int start_create = 2131427407; + // aapt resource value: 0x7f0c0080 + public const int search_label = 2131492992; - // aapt resource value: 0x7f0b0092 - public const int start_create_import = 2131427474; + // aapt resource value: 0x7f0c004f + public const int start_create = 2131492943; - // aapt resource value: 0x7f0b004d - public const int start_open_file = 2131427405; + // aapt resource value: 0x7f0c0093 + public const int start_create_import = 2131493011; - // aapt resource value: 0x7f0b004e - public const int start_open_url = 2131427406; + // aapt resource value: 0x7f0c004d + public const int start_open_file = 2131492941; - // aapt resource value: 0x7f0b000b - public const int text = 2131427339; + // aapt resource value: 0x7f0c004e + public const int start_open_url = 2131492942; - // aapt resource value: 0x7f0b002e - public const int title = 2131427374; + // aapt resource value: 0x7f0c000b + public const int text = 2131492875; - // aapt resource value: 0x7f0b0035 - public const int title_block = 2131427381; + // aapt resource value: 0x7f0c002e + public const int title = 2131492910; - // aapt resource value: 0x7f0b0075 - public const int toggle_password = 2131427445; + // aapt resource value: 0x7f0c0035 + public const int title_block = 2131492917; - // aapt resource value: 0x7f0b0031 - public const int value = 2131427377; + // aapt resource value: 0x7f0c0076 + public const int toggle_password = 2131492982; - // aapt resource value: 0x7f0b0003 - public const int version = 2131427331; + // aapt resource value: 0x7f0c0031 + public const int value = 2131492913; - // aapt resource value: 0x7f0b0002 - public const int version_title = 2131427330; + // aapt resource value: 0x7f0c0003 + public const int version = 2131492867; + + // aapt resource value: 0x7f0c0002 + public const int version_title = 2131492866; private Id() { @@ -958,22 +1017,25 @@ namespace keepass2android public const int icon_picker = 2130903060; // aapt resource value: 0x7f030015 - public const int password = 2130903061; + public const int input = 2130903061; // aapt resource value: 0x7f030016 - public const int QuickUnlock = 2130903062; + public const int password = 2130903062; // aapt resource value: 0x7f030017 - public const int search = 2130903063; + public const int QuickUnlock = 2130903063; // aapt resource value: 0x7f030018 - public const int set_password = 2130903064; + public const int search = 2130903064; // aapt resource value: 0x7f030019 - public const int StartScreenButtons = 2130903065; + public const int set_password = 2130903065; // aapt resource value: 0x7f03001a - public const int url_credentials = 2130903066; + public const int StartScreenButtons = 2130903066; + + // aapt resource value: 0x7f03001b + public const int url_credentials = 2130903067; private Layout() { @@ -983,20 +1045,20 @@ namespace keepass2android public partial class Menu { - // aapt resource value: 0x7f0a0000 - public const int entry = 2131361792; + // aapt resource value: 0x7f0b0000 + public const int entry = 2131427328; - // aapt resource value: 0x7f0a0001 - public const int entry_edit = 2131361793; + // aapt resource value: 0x7f0b0001 + public const int entry_edit = 2131427329; - // aapt resource value: 0x7f0a0002 - public const int fileselect = 2131361794; + // aapt resource value: 0x7f0b0002 + public const int fileselect = 2131427330; - // aapt resource value: 0x7f0a0003 - public const int group = 2131361795; + // aapt resource value: 0x7f0b0003 + public const int group = 2131427331; - // aapt resource value: 0x7f0a0004 - public const int password = 2131361796; + // aapt resource value: 0x7f0b0004 + public const int password = 2131427332; private Menu() { @@ -1006,770 +1068,803 @@ namespace keepass2android public partial class String { - // aapt resource value: 0x7f060025 - public const int AboutText = 2131099685; + // aapt resource value: 0x7f07002d + public const int AboutText = 2131165229; - // aapt resource value: 0x7f0600f3 - public const int AskDeletePermanentlyEntry = 2131099891; + // aapt resource value: 0x7f0700fe + public const int AskDeletePermanentlyEntry = 2131165438; - // aapt resource value: 0x7f0600f4 - public const int AskDeletePermanentlyGroup = 2131099892; + // aapt resource value: 0x7f0700ff + public const int AskDeletePermanentlyGroup = 2131165439; - // aapt resource value: 0x7f0600f5 - public const int AskDeletePermanently_title = 2131099893; + // aapt resource value: 0x7f070100 + public const int AskDeletePermanently_title = 2131165440; - // aapt resource value: 0x7f0600f8 - public const int AskDiscardChanges = 2131099896; + // aapt resource value: 0x7f070103 + public const int AskDiscardChanges = 2131165443; - // aapt resource value: 0x7f0600f9 - public const int AskDiscardChanges_title = 2131099897; + // aapt resource value: 0x7f070104 + public const int AskDiscardChanges_title = 2131165444; - // aapt resource value: 0x7f0600ed - public const int AskOverwriteBinary = 2131099885; + // aapt resource value: 0x7f0700f8 + public const int AskOverwriteBinary = 2131165432; - // aapt resource value: 0x7f0600f0 - public const int AskOverwriteBinary_no = 2131099888; + // aapt resource value: 0x7f0700fb + public const int AskOverwriteBinary_no = 2131165435; - // aapt resource value: 0x7f0600ee - public const int AskOverwriteBinary_title = 2131099886; + // aapt resource value: 0x7f0700f9 + public const int AskOverwriteBinary_title = 2131165433; - // aapt resource value: 0x7f0600ef - public const int AskOverwriteBinary_yes = 2131099887; + // aapt resource value: 0x7f0700fa + public const int AskOverwriteBinary_yes = 2131165434; - // aapt resource value: 0x7f0600f7 - public const int AskReloadFile = 2131099895; + // aapt resource value: 0x7f070102 + public const int AskReloadFile = 2131165442; - // aapt resource value: 0x7f0600f6 - public const int AskReloadFile_title = 2131099894; + // aapt resource value: 0x7f070101 + public const int AskReloadFile_title = 2131165441; - // aapt resource value: 0x7f0600f1 - public const int AttachFailed = 2131099889; + // aapt resource value: 0x7f0700fc + public const int AttachFailed = 2131165436; - // aapt resource value: 0x7f060017 - public const int BinaryDirectory_default = 2131099671; + // aapt resource value: 0x7f07001f + public const int BinaryDirectory_default = 2131165215; - // aapt resource value: 0x7f060016 - public const int BinaryDirectory_key = 2131099670; + // aapt resource value: 0x7f07001e + public const int BinaryDirectory_key = 2131165214; - // aapt resource value: 0x7f0600df - public const int BinaryDirectory_summary = 2131099871; + // aapt resource value: 0x7f0700ea + public const int BinaryDirectory_summary = 2131165418; - // aapt resource value: 0x7f0600de - public const int BinaryDirectory_title = 2131099870; + // aapt resource value: 0x7f0700e9 + public const int BinaryDirectory_title = 2131165417; - // aapt resource value: 0x7f0600fe - public const int ChangeLog = 2131099902; + // aapt resource value: 0x7f070109 + public const int ChangeLog = 2131165449; - // aapt resource value: 0x7f0600fd - public const int ChangeLog_title = 2131099901; + // aapt resource value: 0x7f070108 + public const int ChangeLog_title = 2131165448; - // aapt resource value: 0x7f060039 - public const int ClearClipboard = 2131099705; + // aapt resource value: 0x7f070041 + public const int ClearClipboard = 2131165249; - // aapt resource value: 0x7f060026 - public const int CreditsText = 2131099686; + // aapt resource value: 0x7f07002e + public const int CreditsText = 2131165230; - // aapt resource value: 0x7f06006f - public const int FileNotFound = 2131099759; + // aapt resource value: 0x7f07007a + public const int FileNotFound = 2131165306; - // aapt resource value: 0x7f060082 - public const int InvalidPassword = 2131099778; + // aapt resource value: 0x7f07008d + public const int InvalidPassword = 2131165325; - // aapt resource value: 0x7f06001c - public const int LastInfoVersionCode_key = 2131099676; + // aapt resource value: 0x7f070024 + public const int LastInfoVersionCode_key = 2131165220; - // aapt resource value: 0x7f06001e - public const int MarketURL = 2131099678; + // aapt resource value: 0x7f070026 + public const int MarketURL = 2131165222; - // aapt resource value: 0x7f06008c - public const int MaskedPassword = 2131099788; + // aapt resource value: 0x7f070097 + public const int MaskedPassword = 2131165335; - // aapt resource value: 0x7f060018 - public const int QuickUnlockDefaultEnabled_key = 2131099672; + // aapt resource value: 0x7f070020 + public const int QuickUnlockDefaultEnabled_key = 2131165216; - // aapt resource value: 0x7f0600da - public const int QuickUnlockDefaultEnabled_summary = 2131099866; + // aapt resource value: 0x7f0700e5 + public const int QuickUnlockDefaultEnabled_summary = 2131165413; - // aapt resource value: 0x7f0600d9 - public const int QuickUnlockDefaultEnabled_title = 2131099865; + // aapt resource value: 0x7f0700e4 + public const int QuickUnlockDefaultEnabled_title = 2131165412; - // aapt resource value: 0x7f06001a - public const int QuickUnlockLength_default = 2131099674; + // aapt resource value: 0x7f070022 + public const int QuickUnlockLength_default = 2131165218; - // aapt resource value: 0x7f060019 - public const int QuickUnlockLength_key = 2131099673; + // aapt resource value: 0x7f070021 + public const int QuickUnlockLength_key = 2131165217; - // aapt resource value: 0x7f0600dc - public const int QuickUnlockLength_summary = 2131099868; + // aapt resource value: 0x7f0700e7 + public const int QuickUnlockLength_summary = 2131165415; - // aapt resource value: 0x7f0600db - public const int QuickUnlockLength_title = 2131099867; + // aapt resource value: 0x7f0700e6 + public const int QuickUnlockLength_title = 2131165414; - // aapt resource value: 0x7f0600d7 - public const int QuickUnlock_button = 2131099863; + // aapt resource value: 0x7f0700e2 + public const int QuickUnlock_button = 2131165410; - // aapt resource value: 0x7f0600dd - public const int QuickUnlock_fail = 2131099869; + // aapt resource value: 0x7f0700e8 + public const int QuickUnlock_fail = 2131165416; - // aapt resource value: 0x7f0600d6 - public const int QuickUnlock_label = 2131099862; + // aapt resource value: 0x7f0700e1 + public const int QuickUnlock_label = 2131165409; - // aapt resource value: 0x7f0600d8 - public const int QuickUnlock_lockButton = 2131099864; + // aapt resource value: 0x7f0700e3 + public const int QuickUnlock_lockButton = 2131165411; - // aapt resource value: 0x7f0600f2 - public const int RecycleBin = 2131099890; + // aapt resource value: 0x7f0700fd + public const int RecycleBin = 2131165437; - // aapt resource value: 0x7f0600e1 - public const int SaveAttachment_Failed = 2131099873; + // aapt resource value: 0x7f0700ec + public const int SaveAttachment_Failed = 2131165420; - // aapt resource value: 0x7f0600e0 - public const int SaveAttachment_doneMessage = 2131099872; + // aapt resource value: 0x7f0700eb + public const int SaveAttachment_doneMessage = 2131165419; - // aapt resource value: 0x7f06001f - public const int SuggestionsURL = 2131099679; + // aapt resource value: 0x7f070027 + public const int SuggestionsURL = 2131165223; - // aapt resource value: 0x7f060014 - public const int TanExpiresOnUse_key = 2131099668; + // aapt resource value: 0x7f07001c + public const int TanExpiresOnUse_key = 2131165212; - // aapt resource value: 0x7f0600ca - public const int TanExpiresOnUse_summary = 2131099850; + // aapt resource value: 0x7f0700d5 + public const int TanExpiresOnUse_summary = 2131165397; - // aapt resource value: 0x7f0600c9 - public const int TanExpiresOnUse_title = 2131099849; + // aapt resource value: 0x7f0700d4 + public const int TanExpiresOnUse_title = 2131165396; - // aapt resource value: 0x7f060020 - public const int TranslationURL = 2131099680; + // aapt resource value: 0x7f070028 + public const int TranslationURL = 2131165224; - // aapt resource value: 0x7f06001b - public const int UsageCount_key = 2131099675; + // aapt resource value: 0x7f070023 + public const int UsageCount_key = 2131165219; - // aapt resource value: 0x7f06001d - public const int UseFileTransactions_key = 2131099677; + // aapt resource value: 0x7f070025 + public const int UseFileTransactions_key = 2131165221; - // aapt resource value: 0x7f0600ec - public const int UseFileTransactions_summary = 2131099884; + // aapt resource value: 0x7f0700f7 + public const int UseFileTransactions_summary = 2131165431; - // aapt resource value: 0x7f0600eb - public const int UseFileTransactions_title = 2131099883; + // aapt resource value: 0x7f0700f6 + public const int UseFileTransactions_title = 2131165430; - // aapt resource value: 0x7f060023 - public const int about_feedback = 2131099683; + // aapt resource value: 0x7f07002b + public const int about_feedback = 2131165227; - // aapt resource value: 0x7f060024 - public const int about_homepage = 2131099684; + // aapt resource value: 0x7f07002c + public const int about_homepage = 2131165228; - // aapt resource value: 0x7f060027 - public const int accept = 2131099687; + // aapt resource value: 0x7f07002f + public const int accept = 2131165231; - // aapt resource value: 0x7f0600e7 - public const int add_binary = 2131099879; + // aapt resource value: 0x7f0700f2 + public const int add_binary = 2131165426; - // aapt resource value: 0x7f060028 - public const int add_entry = 2131099688; + // aapt resource value: 0x7f070030 + public const int add_entry = 2131165232; - // aapt resource value: 0x7f0600e8 - public const int add_extra_string = 2131099880; + // aapt resource value: 0x7f0700f3 + public const int add_extra_string = 2131165427; - // aapt resource value: 0x7f060029 - public const int add_group = 2131099689; + // aapt resource value: 0x7f070031 + public const int add_group = 2131165233; - // aapt resource value: 0x7f06002a - public const int add_group_title = 2131099690; + // aapt resource value: 0x7f070032 + public const int add_group_title = 2131165234; - // aapt resource value: 0x7f06002b - public const int algorithm = 2131099691; + // aapt resource value: 0x7f070033 + public const int algorithm = 2131165235; - // aapt resource value: 0x7f06002c - public const int algorithm_colon = 2131099692; + // aapt resource value: 0x7f070034 + public const int algorithm_colon = 2131165236; - // aapt resource value: 0x7f060008 - public const int algorithm_key = 2131099656; + // aapt resource value: 0x7f070010 + public const int algorithm_key = 2131165200; - // aapt resource value: 0x7f060009 - public const int app_key = 2131099657; + // aapt resource value: 0x7f070011 + public const int app_key = 2131165201; - // aapt resource value: 0x7f06002d - public const int app_name = 2131099693; + // aapt resource value: 0x7f070035 + public const int app_name = 2131165237; - // aapt resource value: 0x7f06002f - public const int app_name_nonet = 2131099695; + // aapt resource value: 0x7f070037 + public const int app_name_nonet = 2131165239; - // aapt resource value: 0x7f060031 - public const int app_timeout = 2131099697; + // aapt resource value: 0x7f070039 + public const int app_timeout = 2131165241; - // aapt resource value: 0x7f06000a - public const int app_timeout_key = 2131099658; + // aapt resource value: 0x7f070012 + public const int app_timeout_key = 2131165202; - // aapt resource value: 0x7f060032 - public const int app_timeout_summary = 2131099698; + // aapt resource value: 0x7f07003a + public const int app_timeout_summary = 2131165242; - // aapt resource value: 0x7f060033 - public const int application = 2131099699; + // aapt resource value: 0x7f07003b + public const int application = 2131165243; - // aapt resource value: 0x7f060034 - public const int application_settings = 2131099700; + // aapt resource value: 0x7f07003c + public const int application_settings = 2131165244; - // aapt resource value: 0x7f060035 - public const int brackets = 2131099701; + // aapt resource value: 0x7f070046 + public const int available_through_keyboard = 2131165254; - // aapt resource value: 0x7f060036 - public const int browser_intall_text = 2131099702; + // aapt resource value: 0x7f07003d + public const int brackets = 2131165245; - // aapt resource value: 0x7f060037 - public const int building_search_idx = 2131099703; + // aapt resource value: 0x7f07003e + public const int browser_intall_text = 2131165246; - // aapt resource value: 0x7f060038 - public const int cancel = 2131099704; + // aapt resource value: 0x7f07003f + public const int building_search_idx = 2131165247; - // aapt resource value: 0x7f0600ce - public const int caseSensitive = 2131099854; + // aapt resource value: 0x7f070040 + public const int cancel = 2131165248; - // aapt resource value: 0x7f06003a - public const int clipboard_timeout = 2131099706; + // aapt resource value: 0x7f0700d9 + public const int caseSensitive = 2131165401; - // aapt resource value: 0x7f060021 - public const int clipboard_timeout_default = 2131099681; + // aapt resource value: 0x7f070002 + public const int change_entry = 2131165186; - // aapt resource value: 0x7f06000b - public const int clipboard_timeout_key = 2131099659; + // aapt resource value: 0x7f070042 + public const int clipboard_timeout = 2131165250; - // aapt resource value: 0x7f06003b - public const int clipboard_timeout_summary = 2131099707; + // aapt resource value: 0x7f070029 + public const int clipboard_timeout_default = 2131165225; - // aapt resource value: 0x7f06003d - public const int copy_password = 2131099709; + // aapt resource value: 0x7f070013 + public const int clipboard_timeout_key = 2131165203; - // aapt resource value: 0x7f06003c - public const int copy_username = 2131099708; + // aapt resource value: 0x7f070043 + public const int clipboard_timeout_summary = 2131165251; - // aapt resource value: 0x7f06003e - public const int creating_db_key = 2131099710; + // aapt resource value: 0x7f070045 + public const int copy_password = 2131165253; - // aapt resource value: 0x7f0600ea - public const int credentials_dialog_title = 2131099882; + // aapt resource value: 0x7f070044 + public const int copy_username = 2131165252; - // aapt resource value: 0x7f06003f - public const int current_group = 2131099711; + // aapt resource value: 0x7f070049 + public const int creating_db_key = 2131165257; - // aapt resource value: 0x7f060040 - public const int current_group_root = 2131099712; + // aapt resource value: 0x7f0700f5 + public const int credentials_dialog_title = 2131165429; - // aapt resource value: 0x7f060041 - public const int database = 2131099713; + // aapt resource value: 0x7f07004a + public const int current_group = 2131165258; - // aapt resource value: 0x7f0600e9 - public const int database_loaded_quickunlock_enabled = 2131099881; + // aapt resource value: 0x7f07004b + public const int current_group_root = 2131165259; - // aapt resource value: 0x7f06000c - public const int db_key = 2131099660; + // aapt resource value: 0x7f07004c + public const int database = 2131165260; - // aapt resource value: 0x7f060042 - public const int decrypting_db = 2131099714; + // aapt resource value: 0x7f0700f4 + public const int database_loaded_quickunlock_enabled = 2131165428; - // aapt resource value: 0x7f060043 - public const int decrypting_entry = 2131099715; + // aapt resource value: 0x7f070014 + public const int db_key = 2131165204; - // aapt resource value: 0x7f060044 - public const int default_checkbox = 2131099716; + // aapt resource value: 0x7f07004d + public const int decrypting_db = 2131165261; - // aapt resource value: 0x7f060001 - public const int default_file_path = 2131099649; + // aapt resource value: 0x7f07004e + public const int decrypting_entry = 2131165262; - // aapt resource value: 0x7f0600b6 - public const int default_username = 2131099830; + // aapt resource value: 0x7f07004f + public const int default_checkbox = 2131165263; - // aapt resource value: 0x7f060015 - public const int default_username_key = 2131099669; + // aapt resource value: 0x7f070009 + public const int default_file_path = 2131165193; - // aapt resource value: 0x7f060045 - public const int digits = 2131099717; + // aapt resource value: 0x7f0700c1 + public const int default_username = 2131165377; - // aapt resource value: 0x7f060046 - public const int disclaimer_formal = 2131099718; + // aapt resource value: 0x7f07001d + public const int default_username_key = 2131165213; - // aapt resource value: 0x7f060002 - public const int donate_url = 2131099650; + // aapt resource value: 0x7f070050 + public const int digits = 2131165264; - // aapt resource value: 0x7f060047 - public const int ellipsis = 2131099719; + // aapt resource value: 0x7f070051 + public const int disclaimer_formal = 2131165265; - // aapt resource value: 0x7f0600d5 - public const int enable_quickunlock = 2131099861; + // aapt resource value: 0x7f07000a + public const int donate_url = 2131165194; - // aapt resource value: 0x7f060048 - public const int enter_filename = 2131099720; + // aapt resource value: 0x7f070052 + public const int ellipsis = 2131165266; - // aapt resource value: 0x7f0600d4 - public const int enter_filename_details_create_import = 2131099860; + // aapt resource value: 0x7f0700e0 + public const int enable_quickunlock = 2131165408; - // aapt resource value: 0x7f0600d3 - public const int enter_filename_details_url = 2131099859; + // aapt resource value: 0x7f070053 + public const int enter_filename = 2131165267; - // aapt resource value: 0x7f060049 - public const int entry_accessed = 2131099721; + // aapt resource value: 0x7f0700df + public const int enter_filename_details_create_import = 2131165407; - // aapt resource value: 0x7f06004a - public const int entry_and_or = 2131099722; + // aapt resource value: 0x7f0700de + public const int enter_filename_details_url = 2131165406; - // aapt resource value: 0x7f06005a - public const int entry_binaries = 2131099738; + // aapt resource value: 0x7f070054 + public const int entry_accessed = 2131165268; - // aapt resource value: 0x7f06004b - public const int entry_cancel = 2131099723; + // aapt resource value: 0x7f070055 + public const int entry_and_or = 2131165269; - // aapt resource value: 0x7f06004c - public const int entry_comment = 2131099724; + // aapt resource value: 0x7f070065 + public const int entry_binaries = 2131165285; - // aapt resource value: 0x7f06004f - public const int entry_confpassword = 2131099727; + // aapt resource value: 0x7f070056 + public const int entry_cancel = 2131165270; - // aapt resource value: 0x7f060050 - public const int entry_created = 2131099728; + // aapt resource value: 0x7f070057 + public const int entry_comment = 2131165271; - // aapt resource value: 0x7f060051 - public const int entry_expires = 2131099729; + // aapt resource value: 0x7f07005a + public const int entry_confpassword = 2131165274; - // aapt resource value: 0x7f060059 - public const int entry_extra_strings = 2131099737; + // aapt resource value: 0x7f07005b + public const int entry_created = 2131165275; - // aapt resource value: 0x7f060052 - public const int entry_keyfile = 2131099730; + // aapt resource value: 0x7f07005c + public const int entry_expires = 2131165276; - // aapt resource value: 0x7f060053 - public const int entry_modified = 2131099731; + // aapt resource value: 0x7f070064 + public const int entry_extra_strings = 2131165284; - // aapt resource value: 0x7f06004e - public const int entry_override_url = 2131099726; + // aapt resource value: 0x7f07005d + public const int entry_keyfile = 2131165277; - // aapt resource value: 0x7f060054 - public const int entry_password = 2131099732; + // aapt resource value: 0x7f07005e + public const int entry_modified = 2131165278; - // aapt resource value: 0x7f060055 - public const int entry_save = 2131099733; + // aapt resource value: 0x7f070059 + public const int entry_override_url = 2131165273; - // aapt resource value: 0x7f06004d - public const int entry_tags = 2131099725; + // aapt resource value: 0x7f07005f + public const int entry_password = 2131165279; - // aapt resource value: 0x7f060056 - public const int entry_title = 2131099734; + // aapt resource value: 0x7f070060 + public const int entry_save = 2131165280; - // aapt resource value: 0x7f060057 - public const int entry_url = 2131099735; + // aapt resource value: 0x7f070058 + public const int entry_tags = 2131165272; - // aapt resource value: 0x7f060058 - public const int entry_user_name = 2131099736; + // aapt resource value: 0x7f070061 + public const int entry_title = 2131165281; - // aapt resource value: 0x7f06005b - public const int error_arc4 = 2131099739; + // aapt resource value: 0x7f070062 + public const int entry_url = 2131165282; - // aapt resource value: 0x7f06005c - public const int error_can_not_handle_uri = 2131099740; + // aapt resource value: 0x7f070063 + public const int entry_user_name = 2131165283; - // aapt resource value: 0x7f06005d - public const int error_could_not_create_group = 2131099741; + // aapt resource value: 0x7f070066 + public const int error_arc4 = 2131165286; - // aapt resource value: 0x7f06005e - public const int error_could_not_create_parent = 2131099742; + // aapt resource value: 0x7f070067 + public const int error_can_not_handle_uri = 2131165287; - // aapt resource value: 0x7f06005f - public const int error_database_exists = 2131099743; + // aapt resource value: 0x7f070068 + public const int error_could_not_create_group = 2131165288; - // aapt resource value: 0x7f060060 - public const int error_database_settings = 2131099744; + // aapt resource value: 0x7f070069 + public const int error_could_not_create_parent = 2131165289; - // aapt resource value: 0x7f060061 - public const int error_failed_to_launch_link = 2131099745; + // aapt resource value: 0x7f07006a + public const int error_database_exists = 2131165290; - // aapt resource value: 0x7f060063 - public const int error_file_not_create = 2131099747; + // aapt resource value: 0x7f07006b + public const int error_database_settings = 2131165291; - // aapt resource value: 0x7f060062 - public const int error_filename_required = 2131099746; + // aapt resource value: 0x7f07006c + public const int error_failed_to_launch_link = 2131165292; - // aapt resource value: 0x7f060064 - public const int error_invalid_db = 2131099748; + // aapt resource value: 0x7f07006e + public const int error_file_not_create = 2131165294; - // aapt resource value: 0x7f0600e2 - public const int error_invalid_expiry_date = 2131099874; + // aapt resource value: 0x7f07006d + public const int error_filename_required = 2131165293; - // aapt resource value: 0x7f060065 - public const int error_invalid_path = 2131099749; + // aapt resource value: 0x7f07006f + public const int error_invalid_db = 2131165295; - // aapt resource value: 0x7f060066 - public const int error_no_name = 2131099750; + // aapt resource value: 0x7f0700ed + public const int error_invalid_expiry_date = 2131165421; - // aapt resource value: 0x7f060067 - public const int error_nopass = 2131099751; + // aapt resource value: 0x7f070070 + public const int error_invalid_path = 2131165296; - // aapt resource value: 0x7f060068 - public const int error_out_of_memory = 2131099752; + // aapt resource value: 0x7f070071 + public const int error_no_name = 2131165297; - // aapt resource value: 0x7f060069 - public const int error_pass_gen_type = 2131099753; + // aapt resource value: 0x7f070072 + public const int error_nopass = 2131165298; - // aapt resource value: 0x7f06006a - public const int error_pass_match = 2131099754; + // aapt resource value: 0x7f070073 + public const int error_out_of_memory = 2131165299; - // aapt resource value: 0x7f06006b - public const int error_rounds_not_number = 2131099755; + // aapt resource value: 0x7f070074 + public const int error_pass_gen_type = 2131165300; - // aapt resource value: 0x7f06006c - public const int error_rounds_too_large = 2131099756; + // aapt resource value: 0x7f070075 + public const int error_pass_match = 2131165301; - // aapt resource value: 0x7f0600e3 - public const int error_string_key = 2131099875; + // aapt resource value: 0x7f070076 + public const int error_rounds_not_number = 2131165302; - // aapt resource value: 0x7f06006d - public const int error_title_required = 2131099757; + // aapt resource value: 0x7f070077 + public const int error_rounds_too_large = 2131165303; - // aapt resource value: 0x7f06006e - public const int error_wrong_length = 2131099758; + // aapt resource value: 0x7f0700ee + public const int error_string_key = 2131165422; - // aapt resource value: 0x7f0600cc - public const int excludeExpiredEntries = 2131099852; + // aapt resource value: 0x7f070078 + public const int error_title_required = 2131165304; - // aapt resource value: 0x7f0600e4 - public const int field_name = 2131099876; + // aapt resource value: 0x7f070079 + public const int error_wrong_length = 2131165305; - // aapt resource value: 0x7f0600e5 - public const int field_value = 2131099877; + // aapt resource value: 0x7f0700d7 + public const int excludeExpiredEntries = 2131165399; - // aapt resource value: 0x7f060070 - public const int file_browser = 2131099760; + // aapt resource value: 0x7f0700ef + public const int field_name = 2131165423; - // aapt resource value: 0x7f060071 - public const int generate_password = 2131099761; + // aapt resource value: 0x7f0700f0 + public const int field_value = 2131165424; - // aapt resource value: 0x7f060072 - public const int group = 2131099762; + // aapt resource value: 0x7f07007b + public const int file_browser = 2131165307; - // aapt resource value: 0x7f060073 - public const int hint_comment = 2131099763; + // aapt resource value: 0x7f07007c + public const int generate_password = 2131165308; - // aapt resource value: 0x7f060074 - public const int hint_conf_pass = 2131099764; + // aapt resource value: 0x7f07007d + public const int group = 2131165309; - // aapt resource value: 0x7f060075 - public const int hint_generated_password = 2131099765; + // aapt resource value: 0x7f07007e + public const int hint_comment = 2131165310; - // aapt resource value: 0x7f060076 - public const int hint_group_name = 2131099766; + // aapt resource value: 0x7f07007f + public const int hint_conf_pass = 2131165311; - // aapt resource value: 0x7f060077 - public const int hint_keyfile = 2131099767; + // aapt resource value: 0x7f070080 + public const int hint_generated_password = 2131165312; - // aapt resource value: 0x7f060078 - public const int hint_length = 2131099768; + // aapt resource value: 0x7f070081 + public const int hint_group_name = 2131165313; - // aapt resource value: 0x7f06007a - public const int hint_login_pass = 2131099770; + // aapt resource value: 0x7f070082 + public const int hint_keyfile = 2131165314; - // aapt resource value: 0x7f06007d - public const int hint_override_url = 2131099773; + // aapt resource value: 0x7f070083 + public const int hint_length = 2131165315; - // aapt resource value: 0x7f060079 - public const int hint_pass = 2131099769; + // aapt resource value: 0x7f070085 + public const int hint_login_pass = 2131165317; - // aapt resource value: 0x7f06007e - public const int hint_tags = 2131099774; + // aapt resource value: 0x7f070088 + public const int hint_override_url = 2131165320; - // aapt resource value: 0x7f06007b - public const int hint_title = 2131099771; + // aapt resource value: 0x7f070084 + public const int hint_pass = 2131165316; - // aapt resource value: 0x7f06007c - public const int hint_url = 2131099772; + // aapt resource value: 0x7f070089 + public const int hint_tags = 2131165321; - // aapt resource value: 0x7f06007f - public const int hint_username = 2131099775; + // aapt resource value: 0x7f070086 + public const int hint_title = 2131165318; - // aapt resource value: 0x7f060003 - public const int homepage = 2131099651; + // aapt resource value: 0x7f070087 + public const int hint_url = 2131165319; - // aapt resource value: 0x7f060004 - public const int homepage_short = 2131099652; + // aapt resource value: 0x7f07008a + public const int hint_username = 2131165322; - // aapt resource value: 0x7f060080 - public const int install_from_market = 2131099776; + // aapt resource value: 0x7f07000b + public const int homepage = 2131165195; - // aapt resource value: 0x7f060081 - public const int install_from_website = 2131099777; + // aapt resource value: 0x7f07000c + public const int homepage_short = 2131165196; - // aapt resource value: 0x7f060083 - public const int invalid_algorithm = 2131099779; + // aapt resource value: 0x7f070000 + public const int ime_name = 2131165184; - // aapt resource value: 0x7f060084 - public const int invalid_db_sig = 2131099780; + // aapt resource value: 0x7f07008b + public const int install_from_market = 2131165323; - // aapt resource value: 0x7f060005 - public const int issues = 2131099653; + // aapt resource value: 0x7f07008c + public const int install_from_website = 2131165324; - // aapt resource value: 0x7f060085 - public const int keyfile_does_not_exist = 2131099781; + // aapt resource value: 0x7f07008e + public const int invalid_algorithm = 2131165326; - // aapt resource value: 0x7f060086 - public const int keyfile_is_empty = 2131099782; + // aapt resource value: 0x7f07008f + public const int invalid_db_sig = 2131165327; - // aapt resource value: 0x7f06000e - public const int keyfile_key = 2131099662; + // aapt resource value: 0x7f07000d + public const int issues = 2131165197; - // aapt resource value: 0x7f0600cb - public const int kp2a_findUrl = 2131099851; + // aapt resource value: 0x7f070090 + public const int keyfile_does_not_exist = 2131165328; - // aapt resource value: 0x7f060087 - public const int length = 2131099783; + // aapt resource value: 0x7f070091 + public const int keyfile_is_empty = 2131165329; - // aapt resource value: 0x7f060000 - public const int library_name = 2131099648; + // aapt resource value: 0x7f070016 + public const int keyfile_key = 2131165206; - // aapt resource value: 0x7f060022 - public const int list_size_default = 2131099682; + // aapt resource value: 0x7f0700d6 + public const int kp2a_findUrl = 2131165398; - // aapt resource value: 0x7f060011 - public const int list_size_key = 2131099665; + // aapt resource value: 0x7f070004 + public const int label_go_key = 2131165188; - // aapt resource value: 0x7f060089 - public const int list_size_summary = 2131099785; + // aapt resource value: 0x7f070005 + public const int label_next_key = 2131165189; - // aapt resource value: 0x7f060088 - public const int list_size_title = 2131099784; + // aapt resource value: 0x7f070006 + public const int label_send_key = 2131165190; - // aapt resource value: 0x7f06008a - public const int loading_database = 2131099786; + // aapt resource value: 0x7f070007 + public const int label_subtype_generic = 2131165191; - // aapt resource value: 0x7f06008b - public const int lowercase = 2131099787; + // aapt resource value: 0x7f070092 + public const int length = 2131165330; - // aapt resource value: 0x7f06000f - public const int maskpass_key = 2131099663; + // aapt resource value: 0x7f070008 + public const int library_name = 2131165192; - // aapt resource value: 0x7f06008e - public const int maskpass_summary = 2131099790; + // aapt resource value: 0x7f07002a + public const int list_size_default = 2131165226; - // aapt resource value: 0x7f06008d - public const int maskpass_title = 2131099789; + // aapt resource value: 0x7f070019 + public const int list_size_key = 2131165209; - // aapt resource value: 0x7f06008f - public const int menu_about = 2131099791; + // aapt resource value: 0x7f070094 + public const int list_size_summary = 2131165332; - // aapt resource value: 0x7f060094 - public const int menu_app_settings = 2131099796; + // aapt resource value: 0x7f070093 + public const int list_size_title = 2131165331; - // aapt resource value: 0x7f060090 - public const int menu_change_key = 2131099792; + // aapt resource value: 0x7f070095 + public const int loading_database = 2131165333; - // aapt resource value: 0x7f060091 - public const int menu_copy_pass = 2131099793; + // aapt resource value: 0x7f070096 + public const int lowercase = 2131165334; - // aapt resource value: 0x7f060092 - public const int menu_copy_user = 2131099794; + // aapt resource value: 0x7f070017 + public const int maskpass_key = 2131165207; - // aapt resource value: 0x7f060093 - public const int menu_create = 2131099795; + // aapt resource value: 0x7f070099 + public const int maskpass_summary = 2131165337; - // aapt resource value: 0x7f060095 - public const int menu_db_settings = 2131099797; + // aapt resource value: 0x7f070098 + public const int maskpass_title = 2131165336; - // aapt resource value: 0x7f060096 - public const int menu_delete = 2131099798; + // aapt resource value: 0x7f07009a + public const int menu_about = 2131165338; - // aapt resource value: 0x7f060097 - public const int menu_donate = 2131099799; + // aapt resource value: 0x7f07009f + public const int menu_app_settings = 2131165343; - // aapt resource value: 0x7f060098 - public const int menu_edit = 2131099800; + // aapt resource value: 0x7f07009b + public const int menu_change_key = 2131165339; - // aapt resource value: 0x7f060099 - public const int menu_hide_password = 2131099801; + // aapt resource value: 0x7f07009c + public const int menu_copy_pass = 2131165340; - // aapt resource value: 0x7f06009a - public const int menu_homepage = 2131099802; + // aapt resource value: 0x7f07009d + public const int menu_copy_user = 2131165341; - // aapt resource value: 0x7f06009b - public const int menu_lock = 2131099803; + // aapt resource value: 0x7f07009e + public const int menu_create = 2131165342; - // aapt resource value: 0x7f06009c - public const int menu_open = 2131099804; + // aapt resource value: 0x7f0700a0 + public const int menu_db_settings = 2131165344; - // aapt resource value: 0x7f06009d - public const int menu_rename = 2131099805; + // aapt resource value: 0x7f0700a1 + public const int menu_delete = 2131165345; - // aapt resource value: 0x7f06009e - public const int menu_search = 2131099806; + // aapt resource value: 0x7f0700a2 + public const int menu_donate = 2131165346; - // aapt resource value: 0x7f06009f - public const int menu_url = 2131099807; + // aapt resource value: 0x7f0700a3 + public const int menu_edit = 2131165347; - // aapt resource value: 0x7f0600a0 - public const int minus = 2131099808; + // aapt resource value: 0x7f0700a4 + public const int menu_hide_password = 2131165348; - // aapt resource value: 0x7f0600a1 - public const int never = 2131099809; + // aapt resource value: 0x7f0700a5 + public const int menu_homepage = 2131165349; - // aapt resource value: 0x7f0600a3 - public const int no = 2131099811; + // aapt resource value: 0x7f0700a6 + public const int menu_lock = 2131165350; - // aapt resource value: 0x7f0600a4 - public const int no_keys = 2131099812; + // aapt resource value: 0x7f0700a7 + public const int menu_open = 2131165351; - // aapt resource value: 0x7f0600a5 - public const int no_results = 2131099813; + // aapt resource value: 0x7f0700a8 + public const int menu_rename = 2131165352; - // aapt resource value: 0x7f0600a6 - public const int no_url_handler = 2131099814; + // aapt resource value: 0x7f0700a9 + public const int menu_search = 2131165353; - // aapt resource value: 0x7f060006 - public const int oi_filemanager_market = 2131099654; + // aapt resource value: 0x7f0700aa + public const int menu_url = 2131165354; - // aapt resource value: 0x7f060007 - public const int oi_filemanager_web = 2131099655; + // aapt resource value: 0x7f0700ab + public const int minus = 2131165355; - // aapt resource value: 0x7f060010 - public const int omitbackup_key = 2131099664; + // aapt resource value: 0x7f0700ac + public const int never = 2131165356; - // aapt resource value: 0x7f0600a9 - public const int omitbackup_summary = 2131099817; + // aapt resource value: 0x7f0700ae + public const int no = 2131165358; - // aapt resource value: 0x7f0600a8 - public const int omitbackup_title = 2131099816; + // aapt resource value: 0x7f0700af + public const int no_keys = 2131165359; - // aapt resource value: 0x7f0600a7 - public const int open_recent = 2131099815; + // aapt resource value: 0x7f0700b0 + public const int no_results = 2131165360; - // aapt resource value: 0x7f0600aa - public const int pass_filename = 2131099818; + // aapt resource value: 0x7f0700b1 + public const int no_url_handler = 2131165361; - // aapt resource value: 0x7f0600ab - public const int password_title = 2131099819; + // aapt resource value: 0x7f070047 + public const int not_possible_im_picker = 2131165255; - // aapt resource value: 0x7f0600ac - public const int progress_create = 2131099820; + // aapt resource value: 0x7f07000e + public const int oi_filemanager_market = 2131165198; - // aapt resource value: 0x7f0600ad - public const int progress_title = 2131099821; + // aapt resource value: 0x7f07000f + public const int oi_filemanager_web = 2131165199; - // aapt resource value: 0x7f0600e6 - public const int protection = 2131099878; + // aapt resource value: 0x7f070018 + public const int omitbackup_key = 2131165208; - // aapt resource value: 0x7f0600fb - public const int rate_app = 2131099899; + // aapt resource value: 0x7f0700b4 + public const int omitbackup_summary = 2131165364; - // aapt resource value: 0x7f0600c8 - public const int regular_expression = 2131099848; + // aapt resource value: 0x7f0700b3 + public const int omitbackup_title = 2131165363; - // aapt resource value: 0x7f0600ae - public const int remember_keyfile_summary = 2131099822; + // aapt resource value: 0x7f070003 + public const int open_entry = 2131165187; - // aapt resource value: 0x7f0600af - public const int remember_keyfile_title = 2131099823; + // aapt resource value: 0x7f0700b2 + public const int open_recent = 2131165362; - // aapt resource value: 0x7f0600b0 - public const int remove_from_filelist = 2131099824; + // aapt resource value: 0x7f0700b5 + public const int pass_filename = 2131165365; - // aapt resource value: 0x7f0600b1 - public const int rijndael = 2131099825; + // aapt resource value: 0x7f0700b6 + public const int password_title = 2131165366; - // aapt resource value: 0x7f0600b2 - public const int root = 2131099826; + // aapt resource value: 0x7f070048 + public const int please_activate_keyboard = 2131165256; - // aapt resource value: 0x7f0600b3 - public const int rounds = 2131099827; + // aapt resource value: 0x7f0700b7 + public const int progress_create = 2131165367; - // aapt resource value: 0x7f0600b4 - public const int rounds_explaination = 2131099828; + // aapt resource value: 0x7f0700b8 + public const int progress_title = 2131165368; - // aapt resource value: 0x7f0600b5 - public const int rounds_hint = 2131099829; + // aapt resource value: 0x7f0700f1 + public const int protection = 2131165425; - // aapt resource value: 0x7f06000d - public const int rounds_key = 2131099661; + // aapt resource value: 0x7f070106 + public const int rate_app = 2131165446; - // aapt resource value: 0x7f0600b7 - public const int saving_database = 2131099831; + // aapt resource value: 0x7f0700d3 + public const int regular_expression = 2131165395; - // aapt resource value: 0x7f0600be - public const int search_hint = 2131099838; + // aapt resource value: 0x7f0700b9 + public const int remember_keyfile_summary = 2131165369; - // aapt resource value: 0x7f0600c0 - public const int search_in = 2131099840; + // aapt resource value: 0x7f0700ba + public const int remember_keyfile_title = 2131165370; - // aapt resource value: 0x7f0600b9 - public const int search_label = 2131099833; + // aapt resource value: 0x7f0700bb + public const int remove_from_filelist = 2131165371; - // aapt resource value: 0x7f0600cd - public const int search_options = 2131099853; + // aapt resource value: 0x7f0700bc + public const int rijndael = 2131165372; - // aapt resource value: 0x7f0600bf - public const int search_results = 2131099839; + // aapt resource value: 0x7f0700bd + public const int root = 2131165373; - // aapt resource value: 0x7f06002e - public const int short_app_name = 2131099694; + // aapt resource value: 0x7f0700be + public const int rounds = 2131165374; - // aapt resource value: 0x7f060030 - public const int short_app_name_nonet = 2131099696; + // aapt resource value: 0x7f0700bf + public const int rounds_explaination = 2131165375; - // aapt resource value: 0x7f0600ba - public const int show_password = 2131099834; + // aapt resource value: 0x7f0700c0 + public const int rounds_hint = 2131165376; - // aapt resource value: 0x7f0600bc - public const int sort_db = 2131099836; + // aapt resource value: 0x7f070015 + public const int rounds_key = 2131165205; - // aapt resource value: 0x7f060012 - public const int sort_key = 2131099666; + // aapt resource value: 0x7f0700c2 + public const int saving_database = 2131165378; - // aapt resource value: 0x7f0600bb - public const int sort_name = 2131099835; + // aapt resource value: 0x7f0700c9 + public const int search_hint = 2131165385; - // aapt resource value: 0x7f0600b8 - public const int space = 2131099832; + // aapt resource value: 0x7f0700cb + public const int search_in = 2131165387; - // aapt resource value: 0x7f0600bd - public const int special = 2131099837; + // aapt resource value: 0x7f0700c4 + public const int search_label = 2131165380; - // aapt resource value: 0x7f0600d0 - public const int start_create = 2131099856; + // aapt resource value: 0x7f0700d8 + public const int search_options = 2131165400; - // aapt resource value: 0x7f0600d2 - public const int start_create_import = 2131099858; + // aapt resource value: 0x7f0700ca + public const int search_results = 2131165386; - // aapt resource value: 0x7f0600cf - public const int start_open_file = 2131099855; + // aapt resource value: 0x7f070036 + public const int short_app_name = 2131165238; - // aapt resource value: 0x7f0600d1 - public const int start_open_url = 2131099857; + // aapt resource value: 0x7f070038 + public const int short_app_name_nonet = 2131165240; - // aapt resource value: 0x7f0600fa - public const int suggest_improvements = 2131099898; + // aapt resource value: 0x7f0700c5 + public const int show_password = 2131165381; - // aapt resource value: 0x7f060013 - public const int timeout_key = 2131099667; + // aapt resource value: 0x7f0700c7 + public const int sort_db = 2131165383; - // aapt resource value: 0x7f0600fc - public const int translate_app = 2131099900; + // aapt resource value: 0x7f07001a + public const int sort_key = 2131165210; - // aapt resource value: 0x7f0600c1 - public const int twofish = 2131099841; + // aapt resource value: 0x7f0700c6 + public const int sort_name = 2131165382; - // aapt resource value: 0x7f0600c2 - public const int underline = 2131099842; + // aapt resource value: 0x7f0700c3 + public const int space = 2131165379; - // aapt resource value: 0x7f0600c3 - public const int unsupported_db_version = 2131099843; + // aapt resource value: 0x7f0700c8 + public const int special = 2131165384; - // aapt resource value: 0x7f0600c4 - public const int uppercase = 2131099844; + // aapt resource value: 0x7f0700db + public const int start_create = 2131165403; - // aapt resource value: 0x7f0600c7 - public const int version_label = 2131099847; + // aapt resource value: 0x7f0700dd + public const int start_create_import = 2131165405; - // aapt resource value: 0x7f0600c5 - public const int warning_read_only = 2131099845; + // aapt resource value: 0x7f0700da + public const int start_open_file = 2131165402; - // aapt resource value: 0x7f0600c6 - public const int warning_unmounted = 2131099846; + // aapt resource value: 0x7f0700dc + public const int start_open_url = 2131165404; - // aapt resource value: 0x7f0600a2 - public const int yes = 2131099810; + // aapt resource value: 0x7f070105 + public const int suggest_improvements = 2131165445; + + // aapt resource value: 0x7f07001b + public const int timeout_key = 2131165211; + + // aapt resource value: 0x7f070107 + public const int translate_app = 2131165447; + + // aapt resource value: 0x7f0700cc + public const int twofish = 2131165388; + + // aapt resource value: 0x7f0700cd + public const int underline = 2131165389; + + // aapt resource value: 0x7f0700ce + public const int unsupported_db_version = 2131165390; + + // aapt resource value: 0x7f0700cf + public const int uppercase = 2131165391; + + // aapt resource value: 0x7f0700d2 + public const int version_label = 2131165394; + + // aapt resource value: 0x7f0700d0 + public const int warning_read_only = 2131165392; + + // aapt resource value: 0x7f0700d1 + public const int warning_unmounted = 2131165393; + + // aapt resource value: 0x7f070001 + public const int word_separators = 2131165185; + + // aapt resource value: 0x7f0700ad + public const int yes = 2131165357; private String() { @@ -1779,59 +1874,59 @@ namespace keepass2android public partial class Style { - // aapt resource value: 0x7f090011 - public const int Base = 2131296273; + // aapt resource value: 0x7f0a0011 + public const int Base = 2131361809; - // aapt resource value: 0x7f090001 - public const int Dialog = 2131296257; + // aapt resource value: 0x7f0a0001 + public const int Dialog = 2131361793; - // aapt resource value: 0x7f090006 - public const int ElementText = 2131296262; + // aapt resource value: 0x7f0a0006 + public const int ElementText = 2131361798; - // aapt resource value: 0x7f090007 - public const int ElementTextLarge = 2131296263; + // aapt resource value: 0x7f0a0007 + public const int ElementTextLarge = 2131361799; - // aapt resource value: 0x7f090005 - public const int ElementTextSmall = 2131296261; + // aapt resource value: 0x7f0a0005 + public const int ElementTextSmall = 2131361797; - // aapt resource value: 0x7f09000e - public const int ElementTextTitle = 2131296270; + // aapt resource value: 0x7f0a000e + public const int ElementTextTitle = 2131361806; - // aapt resource value: 0x7f09000d - public const int EntryFieldHeader = 2131296269; + // aapt resource value: 0x7f0a000d + public const int EntryFieldHeader = 2131361805; - // aapt resource value: 0x7f09000f - public const int EntryItem = 2131296271; + // aapt resource value: 0x7f0a000f + public const int EntryItem = 2131361807; - // aapt resource value: 0x7f090010 - public const int ExtraFieldHeader = 2131296272; + // aapt resource value: 0x7f0a0010 + public const int ExtraFieldHeader = 2131361808; - // aapt resource value: 0x7f09000a - public const int GroupAndEntryHeader = 2131296266; + // aapt resource value: 0x7f0a000a + public const int GroupAndEntryHeader = 2131361802; - // aapt resource value: 0x7f090008 - public const int GroupLabel = 2131296264; + // aapt resource value: 0x7f0a0008 + public const int GroupLabel = 2131361800; - // aapt resource value: 0x7f090003 - public const int GroupText = 2131296259; + // aapt resource value: 0x7f0a0003 + public const int GroupText = 2131361795; - // aapt resource value: 0x7f090004 - public const int GroupTextLarge = 2131296260; + // aapt resource value: 0x7f0a0004 + public const int GroupTextLarge = 2131361796; - // aapt resource value: 0x7f090002 - public const int GroupTextSmall = 2131296258; + // aapt resource value: 0x7f0a0002 + public const int GroupTextSmall = 2131361794; - // aapt resource value: 0x7f090000 - public const int NoTitleBar = 2131296256; + // aapt resource value: 0x7f0a0000 + public const int NoTitleBar = 2131361792; - // aapt resource value: 0x7f090009 - public const int WhiteOnBlack = 2131296265; + // aapt resource value: 0x7f0a0009 + public const int WhiteOnBlack = 2131361801; - // aapt resource value: 0x7f09000b - public const int WhiteOnBlackSmall = 2131296267; + // aapt resource value: 0x7f0a000b + public const int WhiteOnBlackSmall = 2131361803; - // aapt resource value: 0x7f09000c - public const int WhiteOnDarkSmall = 2131296268; + // aapt resource value: 0x7f0a000c + public const int WhiteOnDarkSmall = 2131361804; private Style() { @@ -1842,10 +1937,22 @@ namespace keepass2android { // aapt resource value: 0x7f040000 - public const int preferences = 2130968576; + public const int method = 2130968576; // aapt resource value: 0x7f040001 - public const int searchable = 2130968577; + public const int preferences = 2130968577; + + // aapt resource value: 0x7f040002 + public const int qwerty = 2130968578; + + // aapt resource value: 0x7f040003 + public const int searchable = 2130968579; + + // aapt resource value: 0x7f040004 + public const int symbols = 2130968580; + + // aapt resource value: 0x7f040005 + public const int symbols_shift = 2130968581; private Xml() { diff --git a/src/keepass2android/Resources/drawable-hdpi/notify_keyboard.png b/src/keepass2android/Resources/drawable-hdpi/notify_keyboard.png new file mode 100644 index 00000000..3a38e302 Binary files /dev/null and b/src/keepass2android/Resources/drawable-hdpi/notify_keyboard.png differ diff --git a/src/keepass2android/Resources/drawable/notify_keyboard.png b/src/keepass2android/Resources/drawable/notify_keyboard.png new file mode 100644 index 00000000..0e9c1beb Binary files /dev/null and b/src/keepass2android/Resources/drawable/notify_keyboard.png differ diff --git a/src/keepass2android/Resources/values/strings.xml b/src/keepass2android/Resources/values/strings.xml index 8c34bd93..985a4037 100644 --- a/src/keepass2android/Resources/values/strings.xml +++ b/src/keepass2android/Resources/values/strings.xml @@ -28,6 +28,9 @@ Time before clearing clipboard after copying username or password Select to copy username to clipboard Select to copy password to clipboard + Entry is available through KP2A Keyboard + Could not open dialog to select input method. Please activate keyboard manually. + Please enable the Keepass2Android keyboard in your system settings. Creating database key… Current Group Current Group: Root diff --git a/src/keepass2android/intents/Intents.cs b/src/keepass2android/intents/Intents.cs index d37a3b96..2d168e96 100644 --- a/src/keepass2android/intents/Intents.cs +++ b/src/keepass2android/intents/Intents.cs @@ -35,6 +35,7 @@ namespace keepass2android public const String COPY_USERNAME = "keepass2android.copy_username"; public const String COPY_PASSWORD = "keepass2android.copy_password"; + public const String CHECK_KEYBOARD = "keepass2android.check_keyboard"; public const String FILE_BROWSE = "org.openintents.action.PICK_FILE"; public const int REQUEST_CODE_FILE_BROWSE = 987321; diff --git a/src/keepass2android/keepass2android.csproj b/src/keepass2android/keepass2android.csproj index ef573a15..72cfdace 100644 --- a/src/keepass2android/keepass2android.csproj +++ b/src/keepass2android/keepass2android.csproj @@ -583,6 +583,8 @@ + + @@ -644,6 +646,10 @@ {A57B3ACE-5634-469A-88C4-858BB409F356} kp2akeytransform + + {A8779D4D-7C49-4C2F-82BD-2CDC448391DA} + Kp2aKeyboardBinding + diff --git a/src/keepass2android/services/CopyToClipboardService.cs b/src/keepass2android/services/CopyToClipboardService.cs index 239e472b..74ae3e0b 100644 --- a/src/keepass2android/services/CopyToClipboardService.cs +++ b/src/keepass2android/services/CopyToClipboardService.cs @@ -30,6 +30,7 @@ using Android.Widget; using Android.Preferences; using KeePassLib; using KeePassLib.Utility; +using Android.Views.InputMethods; namespace keepass2android { @@ -40,6 +41,8 @@ namespace keepass2android public const int NOTIFY_USERNAME = 1; public const int NOTIFY_PASSWORD = 2; + public const int NOTIFY_KEYBOARD = 3; + public const int CLEAR_CLIPBOARD = 4; public CopyToClipboardService (IntPtr javaReference, JniHandleOwnership transfer) @@ -68,7 +71,7 @@ namespace keepass2android public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId) { - Android.Util.Log.Debug("DEBUG","Received intent to copy to clipboard"); + Android.Util.Log.Debug("DEBUG","Received intent to provide access to entry"); String uuidBytes = intent.GetStringExtra(EntryActivity.KEY_ENTRY); @@ -95,7 +98,8 @@ namespace keepass2android return StartCommandResult.NotSticky; } - displayCopyNotifications(entry); + displayAccessNotifications(entry); + return StartCommandResult.RedeliverIntent; } @@ -117,6 +121,7 @@ namespace keepass2android if ( mNM != null ) { mNM.CancelAll(); mNumElementsToWaitFor= 0; + clearKeyboard(); } Android.Util.Log.Debug("DEBUG", "Destroyed Show-Notification-Receiver."); @@ -131,27 +136,30 @@ namespace keepass2android PendingIntent createDeleteIntent(int requestCode) { Intent intent = new Intent(ACTION_NOTIFICATION_CANCELLED); + Bundle extra = new Bundle(); + extra.PutInt("requestCode", requestCode); + intent.PutExtras(extra); return PendingIntent.GetBroadcast(this, requestCode, intent, PendingIntentFlags.CancelCurrent); } - public void displayCopyNotifications(PwEntry entry) + public void displayAccessNotifications(PwEntry entry) { // Notification Manager mNM = (NotificationManager)GetSystemService(NotificationService); mNM.CancelAll(); mNumElementsToWaitFor = 0; - + clearKeyboard(); String entryName = entry.Strings.ReadSafe(PwDefs.TitleField); if (entry.Strings.ReadSafe(PwDefs.PasswordField).Length > 0) { // only show notification if password is available - Notification password = GetNotification(Intents.COPY_PASSWORD, Resource.String.copy_password, entryName); + Notification password = GetNotification(Intents.COPY_PASSWORD, Resource.String.copy_password, Resource.Drawable.notify, entryName); - password.DeleteIntent = createDeleteIntent(0); + password.DeleteIntent = createDeleteIntent(NOTIFY_PASSWORD); mNM.Notify(NOTIFY_PASSWORD, password); mNumElementsToWaitFor++; @@ -160,12 +168,22 @@ namespace keepass2android if (entry.Strings.ReadSafe(PwDefs.UserNameField).Length > 0) { // only show notification if username is available - Notification username = GetNotification(Intents.COPY_USERNAME, Resource.String.copy_username, entryName); - username.DeleteIntent = createDeleteIntent(1); + Notification username = GetNotification(Intents.COPY_USERNAME, Resource.String.copy_username, Resource.Drawable.notify, entryName); + username.DeleteIntent = createDeleteIntent(NOTIFY_USERNAME); mNumElementsToWaitFor++; mNM.Notify(NOTIFY_USERNAME, username); } + //keyboard + if (makeAccessibleForKeyboard(entry)) + { + // only show notification if username is available + Notification keyboard = GetNotification(Intents.CHECK_KEYBOARD, Resource.String.available_through_keyboard, Resource.Drawable.notify_keyboard, entryName); + keyboard.DeleteIntent = createDeleteIntent(NOTIFY_KEYBOARD); + mNumElementsToWaitFor++; + mNM.Notify(NOTIFY_KEYBOARD, keyboard); + } + if (mNumElementsToWaitFor == 0) { StopSelf(); @@ -177,6 +195,7 @@ namespace keepass2android IntentFilter filter = new IntentFilter(); filter.AddAction(Intents.COPY_USERNAME); filter.AddAction(Intents.COPY_PASSWORD); + filter.AddAction(Intents.CHECK_KEYBOARD); RegisterReceiver(mCopyToClipBroadcastReceiver, filter); //register receiver to get notified when notifications are discarded in which case we can shutdown the service @@ -186,15 +205,72 @@ namespace keepass2android RegisterReceiver(mNotificationDeletedBroadcastReceiver, deletefilter); } - public void OnWaitElementDeleted() + bool makeAccessibleForKeyboard(PwEntry entry) + { + bool hasData = false; + Keepass2android.Kbbridge.KeyboardDataBuilder kbdataBuilder = new Keepass2android.Kbbridge.KeyboardDataBuilder(); + + String[] keys = {PwDefs.UserNameField, + PwDefs.PasswordField, + PwDefs.UrlField, + PwDefs.NotesField, + PwDefs.TitleField + }; + int[] resIds = {Resource.String.entry_user_name, + Resource.String.entry_password, + Resource.String.entry_url, + Resource.String.entry_comment, + Resource.String.entry_title }; + + //add standard fields: + int i=0; + foreach (string key in keys) + { + String value = entry.Strings.ReadSafe(key); + if (value.Length > 0) + { + kbdataBuilder.AddPair(GetString(resIds[i]), value); + hasData = true; + } + i++; + } + //add additional fields: + foreach (var pair in entry.Strings) + { + String key = pair.Key; + + if (!PwDefs.IsStandardField(key)) { + kbdataBuilder.AddPair(pair.Key, entry.Strings.ReadSafe(pair.Key)); + } + } + + + kbdataBuilder.Commit(); + Keepass2android.Kbbridge.KeyboardData.EntryName = entry.Strings.ReadSafe(PwDefs.TitleField); + + return hasData; + + } + + public void OnWaitElementDeleted(int itemId) { mNumElementsToWaitFor--; if (mNumElementsToWaitFor <= 0) { StopSelf(); } + if (itemId == NOTIFY_KEYBOARD) + { + //keyboard notification was deleted -> clear entries in keyboard + clearKeyboard(); + } } + void clearKeyboard() + { + Keepass2android.Kbbridge.KeyboardData.AvailableFields.Clear(); + Keepass2android.Kbbridge.KeyboardData.EntryName = null; + } private Timer mTimer = new Timer(); @@ -227,7 +303,7 @@ namespace keepass2android public override void Run() { String currentClip = Util.getClipboard(mService); - handler.Post( () => { mService.OnWaitElementDeleted(); }); + handler.Post( () => { mService.OnWaitElementDeleted(CLEAR_CLIPBOARD); }); if ( currentClip.Equals(mClearText) ) { Util.copyToClipboard(mService, ""); handler.Post( () => { @@ -241,7 +317,7 @@ namespace keepass2android // Setup to allow the toast to happen in the foreground Handler uiThreadCallback = new Handler(); - private Notification GetNotification(String intentText, int descResId, String entryName) { + private Notification GetNotification(String intentText, int descResId, int drawableResId, String entryName) { String desc = GetString(descResId); String title = GetString(Resource.String.app_name); @@ -249,10 +325,10 @@ namespace keepass2android title += " (" + entryName +")"; - Notification notify = new Notification(Resource.Drawable.notify, desc, Java.Lang.JavaSystem.CurrentTimeMillis()); + Notification notify = new Notification(drawableResId, desc, Java.Lang.JavaSystem.CurrentTimeMillis()); Intent intent = new Intent(intentText); - PendingIntent pending = PendingIntent.GetBroadcast(this, 0, intent, PendingIntentFlags.CancelCurrent); + PendingIntent pending = PendingIntent.GetBroadcast(this, descResId, intent, PendingIntentFlags.CancelCurrent); notify.SetLatestEventInfo(this, title, desc, pending); @@ -273,19 +349,57 @@ namespace keepass2android PwEntry mEntry; - public override void OnReceive(Context context, Intent intent) { + public override void OnReceive(Context context, Intent intent) + { String action = intent.Action; - if ( action.Equals(Intents.COPY_USERNAME) ) { - String username = mEntry.Strings.ReadSafe (PwDefs.UserNameField); - if ( username.Length > 0 ) { + if (action.Equals(Intents.COPY_USERNAME)) + { + String username = mEntry.Strings.ReadSafe(PwDefs.UserNameField); + if (username.Length > 0) + { mService.timeoutCopyToClipboard(username); } - } else if ( action.Equals(Intents.COPY_PASSWORD) ) { + } else if (action.Equals(Intents.COPY_PASSWORD)) + { String password = mEntry.Strings.ReadSafe(PwDefs.PasswordField); - if ( password.Length > 0 ) { + if (password.Length > 0) + { mService.timeoutCopyToClipboard(password); } + } else if (action.Equals(Intents.CHECK_KEYBOARD)) + { + string currentIme = Android.Provider.Settings.Secure.GetString( + mService.ContentResolver, + Android.Provider.Settings.Secure.DefaultInputMethod); + + string kp2aIme = mService.PackageName+"/keepass2android.softkeyboard.KP2AKeyboard"; + + InputMethodManager imeManager = (InputMethodManager)mService.ApplicationContext.GetSystemService(Context.InputMethodService); + + if (currentIme == kp2aIme) + { + imeManager.ToggleSoftInput(ShowSoftInputFlags.Explicit, HideSoftInputFlags.None); + return; + } + + IList inputMethodProperties = imeManager.EnabledInputMethodList; + + if (!inputMethodProperties.Any(imi => imi.Id.Equals(kp2aIme))) + { + Toast.MakeText(mService, Resource.String.please_activate_keyboard, ToastLength.Long).Show(); + Intent settingsIntent = new Intent(Android.Provider.Settings.ActionInputMethodSettings); + settingsIntent.SetFlags(ActivityFlags.NewTask); + mService.StartActivity(settingsIntent); + } + else + { + if (imeManager != null) { + imeManager.ShowInputMethodPicker(); + } else { + Toast.MakeText(mService, Resource.String.not_possible_im_picker, ToastLength.Long).Show(); + } + } } } }; @@ -303,7 +417,7 @@ namespace keepass2android { if (intent.Action == CopyToClipboardService.ACTION_NOTIFICATION_CANCELLED) { - mService.OnWaitElementDeleted(); + mService.OnWaitElementDeleted(intent.Extras.GetInt("requestCode")); } } #endregion