In this new post I inform you of a new mod performed by yours truly: How to use a Wacom Bamboo with a Galaxy Tab 2.

In questo nuovo post vi informo di una nuova modifica effettuata dal sottoscritto: Come usare una Wacom Bamboo su un Galaxy Tab 2.

How to hook up a Wacom Bamboo to a Galaxy Tab 2

You may know from previous posts that I attend university. I bought the Galaxy Tab mainly for that reason. In our university we are allowed to bring laptops, but mine is not lightweight, and bringing that everyday would have meant the complete destruction of my back (which is something I want to avoid).
They should stop calling them "portable" if they're not, don't you think?

When I bought the tab, almost two years ago, the idea was to have it for books, notes, Internet, videos, in short, everything with only one piece of hardware.
Even with the tab though, I still had to bring exercise books, because you can't do everything on it. You cannot draw for example, and that's a problem when you're dealing with a subject like Mathematics, or Computation theory, with automata, which you need to draw to see their flow.

Honestly, I didn't mind this, until...
On September/October 2014, I met a colleague who owns a Samsung Note Pro SM-P905.
This tablet has an S-Pen and a particular screen that allows you to take notes (like a REAL exercise book).
After having a try with this tab (courtesy of this friend), I seriously started thinking about this way of taking notes, no exercise books, only with the tab.

Some of you may think that tablets like these are the solution to trees being detroyed to make paper.
I want to remind you that tablets and computers are not ecological at all, what we are really doing is, getting rid of a problem (trees destruction) with another problem (creation of electronic devices).
The solution then? You may ask.
...
...
...
How am I supposed to know? If I knew that, I guess I would have done something about it.

Ecological and ideological paths apart, I thought this was a good way to avoid bringing too much exercise books.
I could have bought that Note Pro, but the price was a little too high for me (700€, about 774$), and besides, I'm not a rich person, I don't buy new cutting-edge electronic devices every five seconds, just because of some "new and incredible feature", that usually, is only a larger screen.
I hate that kind of thought.

If you follow me since the beginning, you may know that I own a Wacom Bamboo Pen & Touch digitizer and an usb adapter for the Galaxy Tab 2.
I started thinking about simulating the experience, by hooking up the digitizer to the tab.
Obviously the first tentative failed, because the firmware lacked the drivers for it, the digitizer simply would not work. After a lot of research and trial and error, I was able to do that.

The first version of this post was supposed to include a full working firmware for the Galaxy Tab 2 GT-P5100, but unfortunately my compiled firmware had a problem with the Camera app, it would crash for no apparent reason.
Because of that I prefer to give you the instructions on how to do it.

Please note that whatever you do, I decline any responsability in case of damages, remember that I've made a disclaimer page for a reason. Please also notice that if you're not able to complete one or more steps then most likely you cannot perform this mod, whether it is the Linux kernel that does not support the wacom drivers or any other thing.

Here are the prerequisites for this mod:

  • You need a 64 bit GNU/Linux distribution and Oracle JDK 6 or 7 to compile (it seems that OpenJDK may give problems, same goes for Java 8).
  • You have to know a bit about compiling a CyanogenMod rom, if the device you intend to perform the mod on has been covered by the team, you should find a page related to it.
  • I've made this on a GT-P5100 mounting CyanogenMod 11, probably it can be done on other devices with other CyanogenMod versions, but I cannot confirm this. In any case, in this tutorial I will assume you already have a device mounting a CyanogenMod rom, and you're going to perform the mod to the particular version you're mounting.
  • You need plenty of free space on the hard disk, the source code size is very large (40/50 Gb at least).
  • Compiling time will vary according to the computer you're using, and whether you're setting compiling cache (read about it on the page mentioned in step 1) or not. My first compilation took 7 hours WITHOUT cache, but please, consider that the computer I use was released in 2008.

Enough talk, let's start!

  1. First things first, we need to install the repository for the CyanogenMod 11 source code.
    On the CyanogenMod website there are pages dedicated to the compilation of CyanogenMod for single devices, usually the page url is something like http://wiki.cyanogenmod.org/w/Build_for_DEVMODEL where DEVMODEL is the model of the specific device, for example, this is the page for the GT-P5100.
    Follow the instructions on the page to understand what to do.
    As example, here are the commands I had to perform to set up the CyanogenMod source code for GT-P5100:
    cd INSTDIR
    repo init -u https://github.com/CyanogenMod/android.git -b cm-11.0
    repo sync -j4
    cd vendor/cm
    ./get-prebuilts
    cd ../../device/samsung/p5100
    ./extract-files.sh
    cd INSTDIR
    . build/envsetup.sh
    breakfast p5100
    where INSTDIR is the directory you have chosen for the repository.
  2. Now perform the mod (that is, tell the compiling process to compile the wacom driver).
    Go to the directory:
    INSTDIR/kernel/COMPANY/KERNEL/arch/ARCH/configs/
    where:
    • COMPANY is the name of the company that manufactured the device
    • KERNEL is the name of the kernel
    • ARCH is the architecture of the device
    for example, the directory for the GT-P5100 is:
    INSTDIR/kernel/samsung/espresso10/arch/arm/configs/
    here you will find different files, copy the DEVNAME_defconfig file to a safe location, because this file will be later overwritten.
    Notice that DEVNAME is the prefix of the name assigned to the configuration file for your device (if you don't know what the prefix is, search for it in this directory).
    For example, the configuration file for the GT-P5100 is "cyanogenmod_p5100_defconfig".
    Now go to the directory:
    INSTDIR/kernel/COMPANY/KERNEL/
    open a terminal window here, and type:
    make DEVNAME_defconfig
    make menuconfig
    a menu should appear, we're actually editing the Linux kernel for the tab.
    You need to instruct the compiling process to compile the wacom driver.
    Unfortunately, as far as I know, the option location depends on the kernel itself so there's no standard location. I suggest you to go find it for yourself.
    The path that I had to follow for the GT-P5100 was:
    Device Drivers ->
        Input device support ->
            Tablets ->
                Wacom Intuos/Graphire tablet support (USB)
    According to your needs you can set the driver to be compiled separately (M) or within the kernel (*). For the rest of the tutorial I am going to assume you want to compile it separately from the kernel (meaning that, it will be compiled as a "loadable module").
    Once the setting is enabled, press Enter on the "Exit" option until the program asks you to save changes, obviously you have to accept.
    Now, all the changes are saved in the hidden file .config.
    Rename .config in DEVNAME_defconfig and move it to:
    INSTDIR/kernel/COMPANY/KERNEL/arch/ARCH/configs/
    Now you have to check if the driver's source code is up to date.
    When I first compiled the driver, I discovered it did not support the Wacom Bamboo Pen & Touch, but it did support my Wacom Graphire 4.
    Plug the digitizer into your computer, open up a terminal window and type:
    lsusb
    You should have an output similar to this:
    Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
    Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 006 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 007 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 008 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
    Bus 001 Device 002: ID 0bda:0158 Realtek Semiconductor Corp. USB 2.0 multicard reader
    Bus 001 Device 003: ID 04f2:b091 Chicony Electronics Co., Ltd Webcam
    Bus 008 Device 003: ID 04e8:6860 Samsung Electronics Co., Ltd GT-I9100 Phone [Galaxy S II], GT-P7500 [Galaxy Tab 10.1]
    Bus 006 Device 002: ID 056a:00de Wacom Co., Ltd
    Here, you need to read the codes that appear after ID, in this case 056a:00de, which means that the digitizer I am using has 056a as vendor id and 00de as product id.
    Take note of them somewhere, so that you can refer to them later.
    Now open this file with any editor and go to the bottom of it:
    INSTDIR/kernel/COMPANY/KERNEL/drivers/input/tablet/wacom_wac.c
    search for the product id, if you don't find it, then you need to update the driver sources.
    Download the driver from here, and simply overwrite the already existing files.
  3. The official wiki suggests to compile the full firmware if you want to perform mods. I want to make you notice that you can actually compile the kernel only, but this kind of operation is deprecated because you want to avoid conflicts of any kind, especially with kernel versions.
    In standard situations you just need to compile the entire firmware, open a terminal window and type:
    cd INSTDIR
    brunch DEVMODEL
    If you also have a GT-P5100, just type:
    cd INSTDIR
    brunch p5100
    Wait for the process to finish. I remind you that it may take quite a while. Now, if everything went well, you should have a fresh compiled firmware.
    What you want to do is to simply flash it by using clockworkmod (of course remember to perform all the needed backups).
    If you're encountering problems with the firmware, try step 4.
    If not, but you have compiled the driver as a loadable module (M), go to step 5.
    If no problem and the module is within the kernel, skip directly to step 6.
  4. As already said before starting this tutorial, I had problems with the above step. After compiling, my firmware had a problem with the Camera app that I was not able to solve. If you're encountering issues related to something malfunctioning, there is one last possibility.
    For this to work, you have to set the driver as a loadable module (M) so if you didn't, do it (look back to step 2), and restore your previous CyanogenMod rom on your device, the one you know everything worked.
    Now, what you want to do is to compile the kernel only, by typing on a terminal window:
    cd INSTDIR
    mka bootimage
    Wait for the process to finish. Now to go to the directory:
    INSTDIR/out/target/product/DEVMODEL/system/lib/modules
    This is where your compiled driver should be, the name is "wacom.ko".
    Type from a terminal window:
    modinfo wacom.ko
    This will show some information on the driver, what we want to know is the vermagic, which is the proper version of the kernel for which the driver has been compiled.
    Now from your device, open a Terminal app (or use adb shell if you prefer), and type:
    cd /system/lib/modules
    Here you should find similar files, with the .ko extension.
    Now just type:
    modinfo KOFILE
    where KOFILE is any file with .ko extension (it is not important which one).
    Check the vermagic of that file, if both the vermagics, the one from wacom.ko and the one from KOFILE are equal, then it means that your current rom uses the same kernel version, so you won't have any compatibility issue.
    Now, use a terminal window on your computer and perform an adb push:
    adb push wacom.ko /system/lib/modules
  5. Everytime you need to use the digitizer you have to activate the driver:
    For the command is a bit long to perform every time, we're going to make a script to automatize the process.
    Remember when I told you to keep the vendor and product id? Well, now's the time to use them, from your computer, open a new text file, and copy and paste the following code:
    VENDORID=056a
    PRODUCTID=00de
    
    if test $# -ne 1
    then
        echo -e "This command expects only one argument from the following:\n--enable: to enable the driver\n--disable: to disable the driver\n--enableorient: to enable orientation adaptation\n--disableorient: to disable orientation adaptation"
    
    else
        if test "$1" = "--enable"
        then
            insmod /system/lib/modules/wacom.ko
    
        elif test "$1" = "--disable"
        then
            rmmod /system/lib/modules/wacom.ko
     
        elif test "$1" = "--enableorient" || test "$1" = "--disableorient"
        then
            mount -o rw,remount /system
    
            orientationaware=0
    
            if test $1 = "--enableorient"
            then
                orientationaware=1
            fi
    
            echo -e "touch.orientationAware = $orientationaware"  > "/system/usr/idc/Vendor_$VENDORID_Product_$PRODUCTID.idc"
            mount -o ro,remount /system
        else
            echo -e "Unknown option \"$1\", expected one of the following:\n--enable: to enable the driver\n--disable: to disable the driver\n--enableorient: to enable orientation adaptation\n--disableorient: to disable the orientation adaptation"
        fi
    fi
    remember to edit the VENDORID and PRODUCTID variables with YOUR digitizer's vendor and product id.
    Save the file and push it in the /system/bin directory.
    It's time to set the executable flag, otherwise you won't not be able to execute the script. Open a Terminal app (or adb) and type:
    su
    chmod 755 /system/bin/WACOMSCRIPT
    where WACOMSCRIPT is the name you gave to the script file.
    You can enable and disable the wacom driver with a simple command now, all you have to do is open a Terminal app and type:
    su
    WACOMSCRIPT --enable
    to enable the driver, or
    su
    WACOMSCRIPT --disable
    to disable it.
    If you know a bit about shell programming, you'll notice in the script even other expected parameters: --enableorient and --disableorient.
    In normal circumstances, even though the driver is enabled, the system does not adapt the coordinates according to the current screen orientation.
    The only way to let the system do it, is to create an idc file for the digitizer (idc stands for Input Device Configuration, a text file with special commands that Android uses to establish how to interact with certain peripherals) with the rule "touch.orientationAware = 1" (or "0" for the standard, meaning no adaptation).
    I've programmed this possibility because while using the mod at university, I felt the need to disable the adaptation.
    So, thanks to the script, if you want to enable the adaptation you type:
    su
    WACOMSCRIPT --enableorient
    if you want to disable it:
    su
    WACOMSCRIPT --disableorient
  6. Well, now try to hook up your wacom digitizer, you do that, and...
    You're probably wondering if you wasted your time.
    Is something even happening?
    Don't be afraid, your digitizer is working, but guess what?
    You need to enable the option to SHOW THE POINTER.
    The reason this post exists is also because of this option:
    The menu to set this option in fact is implemented into the Settings app, but it is only enabled for devices with S-Pen support, meaning, that all the other devices not belonging to this category, won't have this menu.
    Assuming you keep things this way, the only way to show the pointer is:
    • Open a Terminal Emulator app
    • Become root
    • Go to the directory where the system settings are stored
    • Edit the database to add the entry for the pointer
    Here's a working example of this:
    su
    cd /data/data/com.android.providers.settings/databases
    sqlite3 settings.db
    and in the sqlite3 prompt:
    insert into system (name, value) values ("stylus_icon_enabled", VALUE);
    where VALUE is either "1" to show the pointer or "0" to hide it.
    You can pretty much edit most of the system properties if you know how to.
    Obviously this approach is good only for educational purposes, you're not supposed to change settings this way.
    I propose to you two alternatives, but if you're skilled enough, you should be able to find other ones.
    • Hack the Settings app:
      Find the source code for the Settings app, and once you do, open and edit the file InputMethodAndLanguageSettings.java.
      What you want to do is to search for this portion of code:
      if (pointerSettingsCategory != null) {
          // remove stylus preference for non stylus devices
          if (!getResources().getBoolean(com.android.internal.R.bool.config_stylusGestures)) {
              pointerSettingsCategory.removePreference(mStylusGestures);
              pointerSettingsCategory.removePreference(mStylusIconEnabled);
          }
      
          if (!isHighTouchSensitivitySupported()) {
              pointerSettingsCategory.removePreference(mHighTouchSensitivity);
              mHighTouchSensitivity = null;
          } else {
              mHighTouchSensitivity.setChecked(HighTouchSensitivity.isEnabled());
          }
      Just comment or remove the first inner if, this way:
      if (pointerSettingsCategory != null) {
          // remove stylus preference for non stylus devices
      
          if (!isHighTouchSensitivitySupported()) {
              pointerSettingsCategory.removePreference(mHighTouchSensitivity);
              mHighTouchSensitivity = null;
          } else {
              mHighTouchSensitivity.setChecked(HighTouchSensitivity.isEnabled());
          }
      If you skipped step 4, just compile the entire firmware as seen in step 3.
      If on the contrary you fell in step 4 then you can compile only the Settings app by typing:
      make Settings
      The Settings.apk file should be in the directory:
      INSTDIR/out/target/product/DEVMODEL/system/app/
      now simply push it through adb:
      adb push Settings.apk /system/app
    • Use StylusSettings:
      You can use StylusSettings, an Android app written by me that is a clone of the hidden menu. It is basically the stylus menu on a standalone app.
      You can find this app on my Sourceforge page if you intend to use it.

So, that was all for today's tutorial.
I personally really like this mod, because even though it is a bore to perform and it is for experienced people only, I've found it pretty useful for my studies.
Since I applied this to my tab, I've used the digitizer to take notes and even making exercises.

So, did you find this post useful?
Do you know a better way to perform this?
Do you have any doubts?
Let me know on the comments section below!

Greetings from Antonio Daniele.
See you next month.

Go back to the top, Share, Look at the comments or Comment yourself!

Come collegare una Wacom Bamboo ad un Galaxy Tab 2

Saprete dai post precedenti che frequento l'università. Ho comprato il Galaxy Tab principalmente per questa ragione. Nella nostra università è possibile portare i portatili, ma il mio non è un peso piuma, e portarlo tutti i giorni avrebbe significato la completa distruzione della mia schiena (cosa che voglio evitare).
Dovrebbero smettere di chiamarli "portatili" se non lo sono, non credete?

Quando ho comprato il tablet, quasi due anni fa, l'idea era avere i libri, le note, Internet, i video, in breve, tutto con un solo pezzo d'hardware.
Anche col tablet, ho comunque continuato a portare i quaderni, perché non è possibile farci tutto. Non è possibile disegnare ad esempio, e questo è un problema con materie come Matematica o Teoria della computazione, con gli automi, che è necessario disegnarli per vederne il flusso.

Onestamente, non me ne importava molto, fino a che...
In Settembre/Ottobre 2014, ho conosciuto un collega che possiede un Samsung Note Pro SM-P905.
Questo tablet ha una "S-Pen" e uno schermo particolare, che vi permette di prendere appunti sullo stesso tablet (come se fosse un VERO quanderno).
Dopo aver provato questo tablet (cortesia di questo amico), ho seriamente pensato a questo modo di prendere appunti, niente quaderni, solo il tablet.

Alcuni di voi potrebbero pensare che i tablet come questo sono la soluzione alla distruzione degli alberi per la produzione di carta.
Vi ricordo che i tablet e i computer non sono affatto ecologici, quel che stiamo facendo è, liberarci di un problema (distruzione degli alberi) con un altro problema (creazione di dispositivi elettronici).
La soluzione allora? Mi chiederete.
...
...
...
Come faccio a saperla? Se la sappessi, probabilmente avrei già fatto qualcosa.

Percorsi idelogici ed ecologici a parte, ho pensato che fosse un ottimo modo per evitar di portare troppi quaderni.
Avrei potuto acquistare quel Note Pro, ma il prezzo era per me leggermente troppo alto (700€), e poi, non sono una persona ricca, non compro dispositivi elettronici all'avanguardia, ogni cinque secondi, solo per una qualche "nuova ed incredibile caratteristica", che di solito si rivela essere solo uno schermo più grande.
Odio quel tipo di idea.

Se mi seguite dall'inizio, saprete che possiedo una Wacom Bamboo Pen & Touch e un adattore usb per il Samsung Galaxy Tab 2. Ho iniziato a pensare di simulare l'esperienza, attaccando la tavoletta al tablet.
Ovviamente il primo tentativo fallì, a causa del fatto che il firmware non aveva i driver, infatti la tavoletta non funzionava affatto. Dopo molte ricerche e tentativi, alla fine ci sono riuscito.

La prima versione di questo post doveva includere un firmware completamente funzionante per il Galaxy Tab 2 GT-P5100, ma sfortunatamente il mio firmware compilato aveva un problema con l'app della videocamera, essa andava in crash senza un'apparente ragione.
Per questo motivo preferisco darvi solo le istruzioni su come farlo.

Vi faccio notare che declino ogni responsabilità in caso di danni, ricordatevi che non ho scritto una pagina di esonero di responsabilità per niente. Vi faccio notare anche che se non siete in grado di completare uno o più passi, allora con molta probabilità non potete effettuare questa modifica, che sia un problema del kernel Linux che non supporti il driver wacom o per qualsiasi altra ragione.

Ecco qui i prerequisiti per effettuare la modifica:

  • Avete bisogno di una distribuzione GNU/Linux a 64 bit e il JDK 6 o 7 di Oracle per compilare (pare che OpenJDK possa dare problemi, lo stesso dicasi per Java 8).
  • Dovete conoscere un po' come si compila la CyanogenMod, se il dispositivo su cui intendete effettuare la modifica è già stato documentato dal team, dovreste trovare una pagina che gli riguarda.
  • Io l'ho fatta su un GT-P5100 che monta la CyanogenMod 11, probabilmente può essere fatta anche su altri dispositivi con altre versioni della CyanogenMod, ma non posso confermarlo. In ogni caso, in questo tutorial assumerò che stiate già montando una CyanogenMod, e che farete la modifica su questa particolare versione.
  • Avrete bisogno di parecchio spazio libero sul disco rigido, la dimensione del codice sorgente è veramente grande (40/50 Gb almeno).
  • Il tempo di compilazione varia a seconda del computer che usate, e se è abilitata la cache di compilazione (leggete di più al riguardo nella pagina menzionata nel passo 1) o no. Il mia prima compilazione è durata 7 ore SENZA cache, però considerate che il computer che uso io è stato rilasciato nel 2008.

Basta parlare, iniziamo!

  1. Prima di tutto, installiamo il repository per il codice sorgente di CyanogenMod 11.
    Sul sito di CyanogenMod ci sono pagine dedicate alla compilazione del firmware sui singoli dispositivi, di solito l'indirizzo della pagina è una cosa del tipo http://wiki.cyanogenmod.org/w/Build_for_DEVMODEL dove DEVMODEL è il modello del dispositivo specifico, per esempio, questa è la pagina per il GT-P5100.
    Seguite le istruzioni nella pagina per capire cosa fare.
    Come esempio, ecco i comandi che ho dovuto effettuare per impostare il codice sorgente per il GT-P5100:
    cd INSTDIR
    repo init -u https://github.com/CyanogenMod/android.git -b cm-11.0
    repo sync -j4
    cd vendor/cm
    ./get-prebuilts
    cd ../../device/samsung/p5100
    ./extract-files.sh
    cd INSTDIR
    . build/envsetup.sh
    breakfast p5100
    dove INSTDIR è la cartella che avete scelto per il repository.
  2. Ora effettuate la modifica (cioè, dite al processo di compilazione di compilare il driver wacom).
    Andate nella cartella:
    INSTDIR/kernel/COMPANY/KERNEL/arch/ARCH/configs/
    dove:
    • COMPANY è il nome della compagnia che ha prodotto il dispositivo
    • KERNEL è il nome del kernel
    • ARCH è l'architettura del dispositivo
    ad esempio, la cartella per il GT-P5100 è:
    INSTDIR/kernel/samsung/espresso10/arch/arm/configs/
    qui troverete diversi file, copiate il file DEVNAME_defconfig, in un luogo sicuro, perché questo file verrà in seguito sovrascritto.
    Notate che DEVNAME è il prefisso del nome assegnato al file di configurazione del vostro dispositivo (se non sapete qual'è il prefisso, cercatelo in questa cartella).
    Ad esempio, il file di configurazione del GT-P5100 è "cyanogenmod_p5100_defconfig".
    Ora andate nella cartella:
    INSTDIR/kernel/COMPANY/KERNEL/
    aprite una finestra di terminale qui, e digitate:
    make DEVNAME_defconfig
    make menuconfig
    apparirà un menù, stiamo modificando il kernel Linux per il tablet.
    Dovete istruire il processo di compilazione a compilare anche il driver wacom.
    Sfortunatamente, per quanto ne so, il luogo dove si trova l'opzione dipende dallo stesso kernel, quindi non c'è un luogo predefinito. Vi consiglio di trovarlo da soli.
    Il percorso che ho dovuto seguire io per il GT-P5100 è stato:
    Device Drivers ->
        Input device support ->
            Tablets ->
                Wacom Intuos/Graphire tablet support (USB)
    A seconda delle vostre esigenze potete impostare il driver affinché sia compilato separatamente (M) o all'interno del kernel (*). Per il resto del tutorial assumerò che lo vogliate compilare separatamente (ovvero, verrà compilato come "modulo caricabile").
    Una volta abilitata quest'impostazione premete Invio sull'opzione "Exit" finché il programma non vi chiede di salvare i cambiamenti, ovviamente dovete accettare.
    Ora, tutti i cambiamenti vengono salvati nel file nascosto .config.
    Rinominate .config in DEVNAME_defconfig e spostatelo in:
    INSTDIR/kernel/COMPANY/KERNEL/arch/ARCH/configs/
    Ora dovete controllare che il codice sorgente del driver sia aggiornato.
    Quando ho compilato il driver la prima volta, ho scoperto che non supportava la Wacom Bamboo Pen & Touch, ma supportava la mia Wacom Graphire 4.
    Inserite la tavoletta sul computer, aprite una finestra di terminale e digitate:
    lsusb
    Dovreste avere un risultato di questo tipo:
    Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
    Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 006 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 007 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
    Bus 008 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
    Bus 001 Device 002: ID 0bda:0158 Realtek Semiconductor Corp. USB 2.0 multicard reader
    Bus 001 Device 003: ID 04f2:b091 Chicony Electronics Co., Ltd Webcam
    Bus 008 Device 003: ID 04e8:6860 Samsung Electronics Co., Ltd GT-I9100 Phone [Galaxy S II], GT-P7500 [Galaxy Tab 10.1]
    Bus 006 Device 002: ID 056a:00de Wacom Co., Ltd
    Qui dovete leggere i codici che appaiono dopo ID, in questo caso 056a:00de, il che vuol dire che la tavoletta che sto usando ha 056a come "vendor id" e 00de come "product id".
    Prendetene nota da qualche parte, cosicché dopo possiate farci riferimento.
    Ora aprite questo file con un qualsiasi editor e andate in fondo ad esso:
    INSTDIR/kernel/COMPANY/KERNEL/drivers/input/tablet/wacom_wac.c
    cercate il "product id", se non lo trovate, allora dovete aggiornare i sorgenti del driver.
    Scaricate il driver da qui, e sovrascrivete i file già presenti.
  3. La wiki ufficiale suggerisce di compilare il firmware intero se volete effettuare delle modifiche. Voglio farvi notare che potete compilare anche solo il kernel, ma questo tipo d'operazione è deprecata perché è meglio evitare conflitti di ogni tipo, specialmente con le versioni del kernel.
    In situazioni normali dovete solo compilare l'intero firmware, aprite una finestra di terminale digitate:
    cd INSTDIR
    brunch DEVMODEL
    Se anche voi avete un GT-P5100, dovete digitare:
    cd INSTDIR
    brunch p5100
    Attendete che il processo finisca. Vi ricordo che potrebbe volerci un po'. Ora, se tutto è andato bene, dovreste avere un nuovo firmware compilato.
    Quel che dovete fare è effettuare il "flash" usando clockworkmod (ovviamente ricordatevi di effettuare tutti i salvataggi necessari).
    Se state riscontrando problemi col firmware, provate il passo 4.
    Se non ne avete, ma avete compilato il driver come modulo caricabile (M), andate al passo 5.
    Se non c'è alcun problema e il modulo è all'interno del kernel, saltate direttamente al passo 6.
  4. Come già detto prima di iniziare il tutorial, ho avuto problemi col passo di qui sopra. Dopo la compilazione, il mio firmware aveva problemi che non sono riuscito a risolvere con l'app della videocamera. Se avete problemi di malfunzionamento, c'è un ultima possibilità.
    Perché questo funzioni, dovete impostare il driver come modulo caricabile (M), quindi se non lo avete fatto, fatelo (guardate di nuovo il passo 2), e ripristinate la CyanogenMod precedente sul dispositivo, quella in cui sapevate che tutto funzionava.
    Ora, quel che dovete fare è compilare solo il kernel, digitando da finestra di terminale:
    cd INSTDIR
    mka bootimage
    Aspettate che il processo finisca. Ora andate nella cartella:
    INSTDIR/out/target/product/DEVMODEL/system/lib/modules
    Qui è dove si trova il driver compilato, il nome è "wacom.ko".
    Ora, digitate da terminale:
    modinfo wacom.ko
    Questo vi mostrerà delle informazioni sul driver, quel che vogliamo conoscere è il vermagic, che è la versione del kernel per il quale il driver è stato compilato.
    Ora dal vostro dispositivo, aprite un'app Terminale (o usate adb shell se preferite), e digitate:
    cd /system/lib/modules
    Qui dovreste trovare file simili, con l'estensione .ko.
    Ora digitate semplicemente:
    modinfo KOFILE
    dove KOFILE è un qualsiasi file con l'estensione .ko (non è importante quale).
    Controllate il vermagic di quel file, se ambedue i vermagic, quello di wacom.ko e quello di KOFILE sono uguali, significa che il vostro firmware attuale utilizza lo stessa versione del kernel, quindi non avrete problemi di compatibilità.
    Ora, da una finestra di terminale su computer, effettuate un "adb push":
    adb push wacom.ko /system/lib/modules
  5. Ogni volta che dovete usare la tavoletta dovete ricordarvi di attivare il driver:
    Poiché il comando è un po' lungo da effettuare ogni volta, creeremo uno script per automatizzare il processo.
    Ricordate quando vi ho detto di mantenervi il vendor e il product id? Beh, ora è il momento di usarli, dal vostro computer, aprite un nuovo file di testo, e copiate e incollate il seguente codice:
    VENDORID=056a
    PRODUCTID=00de
    
    if test $# -ne 1
    then
        echo -e "Questo comando si aspetta un solo argomento dai seguenti:\n--enable: per abilitare il driver\n--disable: per disabilitare il driver\n--enableorient: per abilitare l'adattamento all'orientamento\n--disableorient: per disabilitare l'adattamento all'orientamento"
    
    else
        if test "$1" = "--enable"
        then
            insmod /system/lib/modules/wacom.ko
    
        elif test "$1" = "--disable"
        then
            rmmod /system/lib/modules/wacom.ko
     
        elif test "$1" = "--enableorient" || test "$1" = "--disableorient"
        then
            mount -o rw,remount /system
    
            orientationaware=0
    
            if test $1 = "--enableorient"
            then
                orientationaware=1
            fi
    
            echo -e "touch.orientationAware = $orientationaware"  > "/system/usr/idc/Vendor_$VENDORID_Product_$PRODUCTID.idc"
            mount -o ro,remount /system
        else
            echo -e "Opzione \"$1\" sconosciuta, ci si aspettava una delle seguenti:\n--enable: per abilitare il driver\n--disable: per disabilitare il driver\n--enableorient per abilitare l'adattamento all'orientamento\n--disableorient per disabilitare l'adattamento all'orientamento"
        fi
    fi
    ricordatevi di modificare le variabili VENDORID e PRODUCTID con il vendor e product id della VOSTRA tavoletta.
    Salvate il file ed effettuate il "push" nella cartella /system/bin.
    È il momento di impostare il flag d'esecuzione, altrimenti non sarete in grado di eseguire lo script. Aprite un'app Terminale (o adb) e digitate:
    su
    chmod 755 /system/bin/WACOMSCRIPT
    dove WACOMSCRIPT è il nome che avete dato allo script.
    Ora potete abilitare e disabilitare il driver wacom con un semplice comando, tutto quel che dovete fare è aprire un'app Terminale e digitare:
    su
    WACOMSCRIPT --enable
    per abilitare il driver, o
    su
    WACOMSCRIPT --disable
    per disabilitarlo.
    Se conoscete un po' la programmazione shell, noterete nello script anche altri parametri attesi: --enableorient e --disableorient.
    In circostanze normali, anche se il driver è abilitato, il sistema non adatta le coordinate all'attuale orientamento dello schermo.
    L'unico modo perché il sistema lo faccia, è creare un file idc per la stessa tavoletta (idc sta per Input Device Configuration, un file di testo con speciali comandi che Android utilizza per stabilire come interagire con alcune periferiche) con la regola "touch.orientationAware = 1" (o "0" per il valore predefinito, ovvero nessun adattamento).
    Ho inserito anche questa possibilità perché all'università ho sentito più volte la necessità di disabilitare l'adattamento.
    Quindi, grazie allo script, se volete abilitare l'adattamento digitate:
    su
    WACOMSCRIPT --enableorient
    se volete disabilitarlo:
    su
    WACOMSCRIPT --disableorient
  6. Bene, ora provate ad attaccare la tavoletta, lo fate, e...
    Vi state chiedendo se avete perso il vostro tempo.
    Ma sta succedendo qualcosa?
    Non abbiate paura, la vostra tavoletta funziona, ma indovinate?
    Dovete abilitare l'opzione ICONA USO DELLO STILO.
    La ragione perché questo post esiste è anche per via di quest'opzione:
    Il menù per impostare quest'opzione infatti è implementato nell'app Impostazioni, ma viene abilitato solo in dispositivi con il supporto alle "S-Pen", il che vuol dire, che tutti gli altri dispositivi non appartenenti a questa categoria, non avranno questo menù.
    Assumendo che non facciate nulla per migliorare la situazione, l'unico modo per mostrare il puntatore è:
    • Aprire un'app Emulatore di terminale
    • Diventare root
    • Andare nella cartella dove sono salvate le impostazioni di sistema
    • Modificare la base di dati per aggiungere la voce per il puntatore
    Ecco un esempio funzionante di queste operazioni:
    su
    cd /data/data/com.android.providers.settings/databases
    sqlite3 settings.db
    e nel prompt di sqlite3:
    insert into system (name, value) values ("stylus_icon_enabled", VALUE);
    dove VALUE è "1" per mostrare il puntatore o "0" per nasconderlo.
    Potete modificare gran parte delle proprietà del sistema se sapete come fare.
    Ovviamente questo approccio è buono solo per scopi educativi, non dovreste cambiare le impostazioni in questa maniera.
    Vi propongo due alternative, ma se siete abbastanza abili, dovreste trovarne anche altre.
    • Fare un "hack" all'app Impostazioni:
      Trovate il codice sorgente dell'app Impostazioni, e una volta fatto, aprite e modificate il file InputMethodAndLanguageSettings.java.
      Quel che dovete fare è cercare questa porzione di codice:
      if (pointerSettingsCategory != null) {
          // remove stylus preference for non stylus devices
          if (!getResources().getBoolean(com.android.internal.R.bool.config_stylusGestures)) {
              pointerSettingsCategory.removePreference(mStylusGestures);
              pointerSettingsCategory.removePreference(mStylusIconEnabled);
          }
      
          if (!isHighTouchSensitivitySupported()) {
              pointerSettingsCategory.removePreference(mHighTouchSensitivity);
              mHighTouchSensitivity = null;
          } else {
              mHighTouchSensitivity.setChecked(HighTouchSensitivity.isEnabled());
          }
      Commentate o rimuovete il primo if più interno, in questo modo:
      if (pointerSettingsCategory != null) {
          // remove stylus preference for non stylus devices
      
          if (!isHighTouchSensitivitySupported()) {
              pointerSettingsCategory.removePreference(mHighTouchSensitivity);
              mHighTouchSensitivity = null;
          } else {
              mHighTouchSensitivity.setChecked(HighTouchSensitivity.isEnabled());
          }
      Se avete saltato il passo 4, compilate l'intero firmware come avete visto nel passo 3.
      Se al contrario siete caduti nel passo 4 allora potete compilare solo l'app Impostazioni digitando:
      make Settings
      Il file Settings.apk dovrebbe trovarsi nella cartella:
      INSTDIR/out/target/product/DEVMODEL/system/app/
      ora effettuate il "push" tramite adb:
      adb push Settings.apk /system/app
    • Usare StylusSettings:
      Potete usare StylusSettings, un'app Android scritta da me che è un clone del menù nascosto. In pratica è il menù stilo in un'app a sé stante.
      Potete trovare quest'app nella mia pagina Sourceforge se intendete usarla.

Questo è tutto per il tutorial di oggi.
Devo ammettere che mi piace molto questa modifica, perché, anche se è una modifica noiosa da effettuare e per sole persone con esperienza, l'ho trovata molto utile per i miei studi.
Da quando l'ho applicata al mio tablet, ho usato la tavoletta per prendere nota e fare esercizi.

Avete trovato utile questo post?
Conoscete un modo migliore per fare questa cosa?
Avete dei dubbi?
Fatemelo sapere nella sezione dei commenti qui in basso!

Saluti da Antonio Daniele.
Ci si vede il mese prossimo.

Torna in cima, Condividi, Guarda i commenti o Commenta tu stesso!