diff --git a/android/avd/hardware-properties.ini b/android/avd/hardware-properties.ini
index 0e650bb..dabf166 100644
--- a/android/avd/hardware-properties.ini
+++ b/android/avd/hardware-properties.ini
@@ -83,18 +83,6 @@
 abstract    = Keyboard lid support
 description = Whether the QWERTY keyboard can be opened/closed.
 
-# The name of the hardware charmap for this device.
-#
-# NOTE: This should always be the default 'qwerty2' unless you have
-#        modified the system image accordingly. This name is sent to
-#        the kernel at boot time. Using an incorrect name will result
-#        in an unusable machine.
-name        = hw.keyboard.charmap
-type        = string
-default     = qwerty2
-abstract    = Keyboard charmap name
-description = Name of the system keyboard charmap file.
-
 # DPad keys
 name        = hw.dPad
 type        = boolean
diff --git a/android/avd/info.c b/android/avd/info.c
index b8160a8..1ab066c 100644
--- a/android/avd/info.c
+++ b/android/avd/info.c
@@ -1162,22 +1162,3 @@
     AFREE(skinPath);
     return;
 }
-
-char*
-avdInfo_getCharmapFile( AvdInfo* i, const char* charmapName )
-{
-    char        fileNameBuff[PATH_MAX];
-    const char* fileName;
-
-    if (charmapName == NULL || charmapName[0] == '\0')
-        return NULL;
-
-    if (strstr(charmapName, ".kcm") == NULL) {
-        snprintf(fileNameBuff, sizeof fileNameBuff, "%s.kcm", charmapName);
-        fileName = fileNameBuff;
-    } else {
-        fileName = charmapName;
-    }
-
-    return _avdInfo_getContentOrSdkFilePath(i, fileName);
-}
diff --git a/android/avd/info.h b/android/avd/info.h
index 5cb3872..2469f68 100644
--- a/android/avd/info.h
+++ b/android/avd/info.h
@@ -215,12 +215,6 @@
  */
 void         avdInfo_getSkinInfo( AvdInfo*  i, char** pSkinName, char** pSkinDir );
 
-/* Find a charmap file named <charmapName>.kcm for this AVD.
- * Returns the path of the file on success, or NULL if not found.
- * The result string must be freed by the caller.
- */
-char*        avdInfo_getCharmapFile( AvdInfo* i, const char* charmapName );
-
 /* Returns TRUE iff in the Android build system */
 int          avdInfo_inAndroidBuild( AvdInfo*  i );
 
diff --git a/android/main-common.c b/android/main-common.c
index 1b9e26c..94accf7 100644
--- a/android/main-common.c
+++ b/android/main-common.c
@@ -335,6 +335,9 @@
     { NULL, NULL }
 };
 
+/* this is used by hw/events_device.c to send the charmap name to the system */
+const char*    android_skin_keycharmap = NULL;
+
 void
 parse_skin_files(const char*      skinDirPath,
                  const char*      skinName,
@@ -560,6 +563,8 @@
         exit(1);
     }
 
+    android_skin_keycharmap = skin_keyboard_charmap_name(qemulator_get()->keyboard);
+
     /* add an onion overlay image if needed */
     if (opts->onion) {
         SkinImage*  onion = skin_image_find_simple( opts->onion );
diff --git a/android/main.c b/android/main.c
index e71301c..ec7ea61 100644
--- a/android/main.c
+++ b/android/main.c
@@ -1031,30 +1031,9 @@
         args[n++] = opts->http_proxy;
     }
 
-    if (!opts->charmap) {
-        /* Try to find a valid charmap name */
-        char* charmap = avdInfo_getCharmapFile(avd, hw->hw_keyboard_charmap);
-        if (charmap != NULL) {
-            D("autoconfig: -charmap %s", charmap);
-            opts->charmap = charmap;
-        }
-    }
-
     if (opts->charmap) {
-        char charmap_name[AKEYCHARMAP_NAME_SIZE];
-
-        if (!path_exists(opts->charmap)) {
-            derror("Charmap file does not exist: %s", opts->charmap);
-            exit(1);
-        }
-        /* We need to store the charmap name in the hardware configuration.
-         * However, the charmap file itself is only used by the UI component
-         * and doesn't need to be set to the emulation engine.
-         */
-        kcm_extract_charmap_name(opts->charmap, charmap_name,
-                                 sizeof(charmap_name));
-        AFREE(hw->hw_keyboard_charmap);
-        hw->hw_keyboard_charmap = ASTRDUP(charmap_name);
+        args[n++] = "-charmap";
+        args[n++] = opts->charmap;
     }
 
     if (opts->memcheck) {
diff --git a/android/qemulator.c b/android/qemulator.c
index 35587ff..9e88356 100644
--- a/android/qemulator.c
+++ b/android/qemulator.c
@@ -137,7 +137,17 @@
     emulator->aconfig     = aconfig;
     emulator->layout_file = skin_file_create_from_aconfig(aconfig, basepath);
     emulator->layout      = emulator->layout_file->layouts;
-    emulator->keyboard    = skin_keyboard_create(opts->charmap, opts->raw_keys);
+    // If we have a custom charmap use it to initialize keyboard.
+    // Otherwise initialize keyboard from configuration settings.
+    // Another way to configure keyboard to use a custom charmap would
+    // be saving a custom charmap name into AConfig's keyboard->charmap
+    // property, and calling single skin_keyboard_create_from_aconfig
+    // routine to initialize keyboard.
+    if (NULL != opts->charmap) {
+        emulator->keyboard = skin_keyboard_create_from_kcm(opts->charmap, opts->raw_keys);
+    } else {
+        emulator->keyboard = skin_keyboard_create_from_aconfig(aconfig, opts->raw_keys);
+    }
     emulator->window      = NULL;
     emulator->win_x       = x;
     emulator->win_y       = y;
diff --git a/android/skin/keyboard.c b/android/skin/keyboard.c
index 3371799..3ee3366 100644
--- a/android/skin/keyboard.c
+++ b/android/skin/keyboard.c
@@ -72,6 +72,15 @@
 }
 
 
+const char*
+skin_keyboard_charmap_name( SkinKeyboard*  keyboard )
+{
+    if (keyboard && keyboard->charmap)
+        return keyboard->charmap->name;
+
+    return DEFAULT_ANDROID_CHARMAP;
+}
+
 void
 skin_keyboard_set_rotation( SkinKeyboard*     keyboard,
                             SkinRotation      rotation )
@@ -530,18 +539,25 @@
 }
 
 SkinKeyboard*
-skin_keyboard_create( const char*  kcm_file_path, int  use_raw_keys )
+skin_keyboard_create_from_aconfig( AConfig*  aconfig, int  use_raw_keys )
 {
-    const char* charmap_name = DEFAULT_ANDROID_CHARMAP;
-    char        cmap_buff[AKEYCHARMAP_NAME_SIZE];
-
-    if (kcm_file_path != NULL) {
-        kcm_extract_charmap_name(kcm_file_path, cmap_buff, sizeof cmap_buff);
-        charmap_name = cmap_buff;
+    const char*    charmap_name = DEFAULT_ANDROID_CHARMAP;
+    AConfig*       node = aconfig_find( aconfig, "keyboard" );
+    if (node != NULL) {
+        charmap_name = aconfig_str(node, "charmap", charmap_name);
     }
     return skin_keyboard_create_from_charmap_name(charmap_name, use_raw_keys);
 }
 
+SkinKeyboard*
+skin_keyboard_create_from_kcm( const char*  kcm_file_path, int  use_raw_keys )
+{
+    char charmap_name[AKEYCHARMAP_NAME_SIZE];
+    kcm_extract_charmap_name(kcm_file_path, charmap_name,
+                             sizeof(charmap_name));
+    return skin_keyboard_create_from_charmap_name(charmap_name, use_raw_keys);
+}
+
 void
 skin_keyboard_free( SkinKeyboard*  keyboard )
 {
diff --git a/android/skin/keyboard.h b/android/skin/keyboard.h
index 1c3b088..a86b132 100644
--- a/android/skin/keyboard.h
+++ b/android/skin/keyboard.h
@@ -24,8 +24,9 @@
 
 typedef void (*SkinKeyEventFunc)( void*  opaque, AndroidKeyCode  code, int  down );
 
-/* If kcm_file_path is NULL, create a keyboard using the default built-in qwerty2 charmap */
-extern SkinKeyboard*  skin_keyboard_create( const char*  kcm_file_path, int  use_raw_keys );
+extern SkinKeyboard*  skin_keyboard_create_from_aconfig( AConfig*  aconfig, int  use_raw_keys );
+
+extern SkinKeyboard*  skin_keyboard_create_from_kcm( const char*  kcm_file_path, int  use_raw_keys );
 
 extern void           skin_keyboard_set_keyset( SkinKeyboard*  keyboard, SkinKeyset*  kset );
 
diff --git a/hw/goldfish_events_device.c b/hw/goldfish_events_device.c
index a5b2a21..3072e3b 100644
--- a/hw/goldfish_events_device.c
+++ b/hw/goldfish_events_device.c
@@ -102,6 +102,8 @@
     return qemu_get_struct(f, events_state_fields, s);
 }
 
+extern const char*  android_skin_keycharmap;
+
 static void enqueue_event(events_state *s, unsigned int type, unsigned int code, int value)
 {
     int  enqueued = s->last - s->first;
@@ -167,11 +169,22 @@
     return n;
 }
 
+static const char*
+get_charmap_name(events_state *s)
+{
+    if (s->name != NULL)
+        return s->name;
+
+    s->name = android_get_charmap_name();
+    return s->name;
+}
+
+
 static int get_page_len(events_state *s)
 {
     int page = s->page;
     if (page == PAGE_NAME) {
-        const char* name = s->name;
+        const char* name = get_charmap_name(s);
         return strlen(name);
     } if (page >= PAGE_EVBITS && page <= PAGE_EVBITS + EV_MAX)
         return s->ev_bits[page - PAGE_EVBITS].len;
@@ -187,7 +200,7 @@
     if (offset > page_len)
         return 0;
     if (page == PAGE_NAME) {
-        const char* name = s->name;
+        const char* name = get_charmap_name(s);
         return name[offset];
     } if (page >= PAGE_EVBITS && page <= PAGE_EVBITS + EV_MAX)
         return s->ev_bits[page - PAGE_EVBITS].bits[offset];
@@ -334,6 +347,9 @@
 
     s = (events_state *) qemu_mallocz(sizeof(events_state));
 
+    // charmap name will be determined on demand
+    s->name = NULL;
+
     /* now set the events capability bits depending on hardware configuration */
     /* apparently, the EV_SYN array is used to indicate which other
      * event classes to consider.
@@ -498,7 +514,6 @@
     s->first = 0;
     s->last = 0;
     s->state = STATE_INIT;
-    s->name = qemu_strdup(config->hw_keyboard_charmap);
 
     /* This function migh fire buffered events to the device, so
      * ensure that it is called after initialization is complete