Showing posts with label Eclipse. Show all posts
Showing posts with label Eclipse. Show all posts

Thursday, July 16, 2015

Aplicaţii IoT cu Java ME Embedded 8 şi Eclipse

(Publicat în revista Today Software Magazine, Numărul 37, Iulie 2015: http://www.todaysoftmag.ro/article/1538/aplicatii-iot-cu-java-me-embedded-8-si-eclipse)

Aplicaţiile Java ME Embedded 8, în forma lor cea mai simplă, sunt uşor de configurat şi gestionat, aşa cum am văzut în articolul din numărul precedent al revistei Today Software Magazine. Totuşi, în cadrul proiectelor software moderne avem nevoie de unelte care să automatizeze anumiţi paşi, să ne atenţioneze atunci când suntem pe punctul de a introduce erori de programare în codul sursă, cu alte cuvinte, să ne sporească productivitatea.

La momentul scrierii acestui material, Oracle oferă suport pentru două dintre cele mai cunoscute medii integrate de dezvoltare, Eclipse şi NetBeans. În acest articol vom discuta despre uneltele pe care le avem la dispoziţie folosind Eclipse, întrucât acest IDE se bucură de un număr mai mare de utilizatori, după cum arată unele surse. Astfel, similar articolului precedent, vom arăta care sunt pachetele software pe care trebuie să le instalăm şi cum putem crea o aplicaţie Java ME Embedded 8 cu Eclipse.

Tooling pentru aplicaţii ME cu Eclipse - Plugin-uri necesare

Pentru a putea urmări paşii prezentaţi în acest articol, avem nevoie, în primul rând, de Oracle Java ME SDK 8.1, pachet software prezentat în articolul Aplicații IoT cu Java ME Embedded 8. De aceea, încurajăm cititorii să răsfoiască numărul 36 al revistei, pentru a afla mai multe despre acest SDK. Pentru a putea beneficia de toate funcţionalităţile pe care Oracle Java ME SDK 8.1 ni le pune la dispoziţie, următorul lucru pe care trebuie să-l facem este să instalăm plugin-urile Java ME SDK Tools. În plus, Oracle ne oferă o serie de proiecte demonstrative, distribuite cu ajutorul plugin-ului Java ME SDK Demos. Aceste pachete pe care tocmai le-am amintit depind de extensia ce poartă numele Mobile Tools for Java sau, pe scurt, MTJ. În mod normal, MTJ se instalează automat împreună cu plugin-urile Java ME SDK Tools, însă în cazul în care acest lucru nu se întâmplă, putem adăuga manual această extensie distribuţiei noastre Eclipse, prin intermediul opţiunii Install New Software din cadrul meniului Help. Mai multe detalii despre instalarea acestor unelte, dar şi despre instalarea Eclipse, putem găsi în documentul Oracle Java Micro Edition Software Development Kit, Developer's Guide.

Crearea unui proiect

O dată ce au fost instalate plugin-urile Java ME SDK Tools şi extensiile MTJ, putem accesa perspectiva Java ME, care ne întâmpină cu o pagină de bun venit, ilustrată în următoarea captură de ecran:

Pagina de bun venit a perspectivei Java ME

Eclipse împreună cu MTJ ne oferă câteva şabloane, care ne ajută să creăm mai rapid proiecte Java ME şi componente ale acestora. Acest lucru este demonstrat în figura următoare:

Şabloane disponibile pentru dezvoltarea aplicaţiilor Java ME

În continuare, dorim să creăm un proiect simplu cu ajutorul noilor unelte pe care tocmai le-am instalat. Pentru aceasta, alegem opţiunea Java ME Project din fereastra de tip dialog Select a wizard. Apăsând Next, ajungem la fereastra în care ni se cere să introducem un nume pentru proiectul nostru. Pentru acest exemplu ne vom folosi de codul listat şi discutat în documentul Oracle Java ME Embedded, Developer's Guide, capitolul General Purpose Input/Output. Acest exemplu ne arată cum putem accesa pinii GPIO (General Purpose Input/Output) ai unei plăcuţe de dezvoltare. La fel ca în articolul precedent, vom folosi un dispozitiv Raspberry PI Model B+.

Revenind la paşii pe care trebuie să-i urmăm pentru a crea un astfel de proiect cu Eclipse şi MTJ, introducem în câmpul Project name numele LEDSwitcher, întrucât dorim să realizăm o aplicaţie care să deschidă şi să închidă un LED (Light-emitting diode), o dată la câteva secunde. Aceeaşi fereastră ne permite să dăm un alt nume fişierului JAD (Java Application Descriptor) şi să facem alte configurări legate de proiectul Eclipse. O dată ce am dat un nume proiectului nostru, mediul de dezvoltare ne avertizează că trebuie să alegem cel puţin o configuraţie pe care va fi rulată aplicaţia. Astfel, apăsăm butonul Add... din partea mediană a ferestrei şi ni se prezintă un alt dialog, cu titlul Add Configuration. Din meniul drop-down SDK alegem Oracle Java(TM) Platform Micro Edition SDK 8.1, iar Eclipse completează automat câmpurile Configuration Name şi Device cu valoarea EmbeddedDevice1. Apăsăm butonul Finish pentru a reveni la dialogul anterior. În acest moment putem apăsa Finish în dialogul New Java ME Project deoarece vom accepta valorile prestabilite propuse de IDE.

Imediat ce proiectul a fost creat, Eclipse deschide un editor, care ne permite să edităm proprietăţi ce ţin de Application Descriptor, dar şi să facem alte configurări. Vedem acest editor ilustrat în figura următoare:

Privire de ansamblu asupra configuraţiei proiectului

Accesarea pinilor GPIO

Este timpul să prezentăm codul sursă care accesează pinii GPIO şi, pentru aceasta, creăm o clasă LEDSwitcher, care extinde clasa abstractă javax.microedition.midlet.MIDlet. În cele ce urmează, prezentăm codul sursă al acestei clase, iar apoi vom analiza câteva aspecte importante:

package ro.leje;

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.microedition.midlet.MIDlet;
import jdk.dio.DeviceManager;
import jdk.dio.gpio.GPIOPin;

public class LEDSwitcher extends MIDlet {

    private static final int PIN_NUMBER = 7;
    private static final int SLEEP_TIME_MILLIS = 2000;

    private GPIOPin pin;

    public void startApp() {
        try {
            pin = DeviceManager.open(PIN_NUMBER);
            Thread.sleep(SLEEP_TIME_MILLIS);
            for (int i = 0; i < 20; i++) {
                System.out.println("Setting pin to true");
                pin.setValue(true);
                Thread.sleep(SLEEP_TIME_MILLIS);
                System.out.println("Setting pin to false");
                pin.setValue(false);
                Thread.sleep(SLEEP_TIME_MILLIS);
            }
        } catch (IOException e) {
            Logger.getLogger(LEDSwitcher.class.getName()).
                log(Level.SEVERE, null, e);
        } catch (InterruptedException e) {
            Logger.getLogger(LEDSwitcher.class.getName()).
                log(Level.SEVERE, null, e);
        }
    }

    public void destroyApp(boolean unconditional) {
        try {
            if (pin != null) {
                pin.close();
            }
        } catch (IOException e) {
            Logger.getLogger(LEDSwitcher.class.getName()).
                log(Level.SEVERE, null, e);
        }
    }
}

Cu ajutorul clasei DeviceManager, care oferă servicii de gestionare a dispozitivelor de tip Device, deschidem pinul GPIO cu numărul 7 al plăcuţei noastre Raspberry PI. Acesta este referit prin variabila pin de tip GPIOPin, căreia putem să-i setăm valoarea ca true sau false, reprezentând stările de high şi low. În metoda startApp() alternăm aceste stări de douăzeci de ori, făcând pauză de două secunde la fiecare iteraţie. În cadrul metodei destroyApp() eliberăm resursele folosite, respectiv închidem dispozitivul ce reprezintă pinul GPIO.

Dorim acum să testăm aplicaţia LEDSwitcher dar, pentru a face lucrurile mai interesante, vom încerca să o instalăm pe dispozitivul Raspberry PI. Aşa cum am văzut în articolul la care am făcut referire mai sus, trebuie să lansăm în execuţie mediul Java ME, şi putem face acest lucru conectându-ne la plăcuţă prin SSH. O dată ce am făcut acest lucru rulând scriptul usertest.sh, înregistrăm dispozitivul cu ajutorul utilitarului Device Manager pe care ni-l pune la dispoziţie SDK-ul. Faptul că RPi este înregistrat se reflectă şi în view-ul Device Selector pe care perspectiva Java ME l-a deschis automat:

*View*-ul *Device Selector*

Acum putem apăsa click-dreapta pe elementul ce reprezintă plăcuţa RPi, şi să alegem din meniul de context Run Project şi apoi numele proiectului nostru. Platforma deschide aplicaţia Java ME Embedded Emulator şi instalează aplicaţia, încercând să o pornească. În acest moment observăm că aplicaţia emulator afişează o fereastră pop-up, care ne avertizează că lansarea aplicaţiei a eşuat. Pentru a afla cauza, putem fie să analizăm view-ul Console din IDE, fie terminalul PuTTY. Amândouă ne arată că s-a aruncat o excepţie java.security.AccessControlException atunci când am încercat să deschidem dispozitivul de tip GPIOPin. De asemenea, log-ul ne oferă o informaţie importantă, prin mesajul

[CRITICAL] [SECURITY] iso=2:Permission check failed: jdk.dio.DeviceMgmtPermission "GPIO7:7" "open"

În primul articol din această serie am amintit faptul că securitatea este unul dintre cele mai importante aspecte ale creării aplicaţiilor IoT. Java ME Embedded 8 ia în serios acest lucru şi implementează mecanisme moderne pentru a asigura un nivel de securitate ridicat. Astfel, pentru a accesa pinul plăcuţei trebuie să permitem acest lucru setând permisiunea jdk.dio.DeviceMgmtPermission pentru dispozitivul GPIO7:7, cu acţiunea open.

Eclipse ne pune la dispoziţie tab-ul Security al editorului despre care am amintit mai devreme unde, în cadrul secţiunii Required Permissions, putem adăuga permisiuni, apăsând butonul Add.... Acest pas este ilustrat în următoarea captură de ecran:

Adăugarea unei permisiuni

Salvăm modificările, care se reflectă în descriptorul aplicaţiei, LEDSwitcher.jad, şi lansăm aplicaţia în execuţie, folosind acelaşi mecanism. De data aceasta, observăm că aplicaţia rulează fără probleme:

Mesajele scrise de aplicaţie în consolă

Dacă realizăm montajul folosind un LED, o rezistenţă, un breadboard şi doi conectori, obţinem configuraţia prezentată în imaginea de mai jos. Vedem, de asemenea, că LED-ul s-a aprins atunci când valoarea pinului a fost setată la true.

Montajul folosind plăcuţa *Raspberry PI*

Debugging cu Eclipse

Una dintre cele mai importante activităţi implicate în dezvoltarea produselor software este cea de debugging. Cu siguranţă fiecare inginer software care foloseşte mediul de dezvoltare Eclipse a intrat în contact cu uneltele de debugging consacrate pe care acesta ni le pune la dispoziţie.

Şi în cazul aplicaţiilor Java ME Embedded 8 putem folosi perspectiva Debug, împreună cu toate view-urile cunoscute. Este interesant faptul că putem face debugging chiar şi atunci când rulăm aplicaţia pe dispozitivul real, nu suntem obligaţi să o instalăm pe un dispozitiv emulat. Folosind fereastra de tip dialog Debug Configurations putem seta diverşi parametri, cum ar fi dispozitivul pe care dorim să rulăm aplicaţia, care este MIDlet-ul ce trebuie executat etc. Stabilind breakpoint-uri în codul sursă şi lansând aplicaţia în modul debug, execuţia se va opri la liniile pe care dorim să le investigăm.

Concluzii

Dezvoltarea aplicaţiilor IoT utilizând platforma Java ME Embedded 8 este alcătuită dintr-un complex de activităţi care aparţin mai multor discipline, printre care se numără ingineria software, bineînţeles, dar şi electronica. Realizând care este complexitatea unei astfel de configuraţii, care implică hardware diferit de maşina pe care se face dezvoltarea, putem să ne dăm seama de beneficiile multiple pe care le aduce o platformă cum este SDK-ul, dar şi uneltele de dezvoltare precum Eclipse sau NetBeans.

Wednesday, June 24, 2015

Aplicații IoT cu Java ME Embedded 8

(Publicat în revista Today Software Magazine, Numărul 36, Iunie 2015: http://issuu.com/todaysoftmag/docs/tsm_36_2015_ro)

În numărul 31 al revistei am făcut o introducere în ceea ce privește subiectul Internet of Things din perspectiva platformei Java. Așa cum am promis, vom continua această discuție prezentând detaliile creării unui proiect Java ME Embedded 8. Această versiune reprezintă un important pas înainte, odată cu adoptarea CLDC 8 - care este un sub-set al Java Standard Edition - și MEEP 8 - specificație care definește un mediu puternic și flexibil pentru sisteme embedded de dimensiuni reduse. Alături de acestea, trebuie să remarcăm alinierea platformei despre care discutăm la Java SE 8.

Tooling pentru aplicaţii ME - Oracle Java ME SDK 8.1

Aplicațiile Micro Edition pot fi dezvoltate atât manual, cât și cu ajutorul unui SDK dedicat, cunoscut sub numele Oracle Java ME SDK 8.1. SDK-ul, distribuţia Java ME, documentaţia şi orice alte resurse mai sunt necesare dezvoltării aplicaţiilor embedded, se găsesc la adresa Oracle dedicată platformei.

Înainte de a începe să dezvoltăm aplicaţii embedded, Oracle recomandă, în primul rând, instalarea Oracle Java ME SDK 8.1 - pachet software care la momentul scrierii acestui articol este disponibil doar pentru sistemul de operare Windows. Următorul pas este descărcarea distribuţiei Java ME Embedded 8 destinată dispozitivului pe care dorim să rulăm aplicaţiile. Aceasta vine sub forma unei arhive ZIP şi trebuie transferată pe dispozitiv - cu ajutorul unui tool cum este PuTTY -, unde urmează să fie instalată. De asemenea, se recomandă păstrarea unei cópii pe sistemul desktop, unde se va executa dezvoltarea aplicaţiilor. Acest ultim pas nu este obligatoriu, însă este recomandat pentru cazul în care dezvoltatorul doreşte să execute comenzi pe dispozitiv cu ajutorul AMS CLI (Application Management System Command Line), prin intermediul programului Developer Agent.

Prima noastră aplicaţie Java ME

Odată ce am instalat SDK-ul şi Java ME, putem să începem dezvoltarea unei aplicaţii embedded. Sub forma ei cea mai simplă, o astfel de aplicaţie trebuie să conţină o clasă care extinde clasa abstractă javax.microedition.midlet.MIDlet, un fişier manifest şi un fişier JAD (Java Application Descriptor). Am putea scrie o astfel de aplicaţie manual, fără ajutorul unui IDE, care să automatizeze anumiţi paşi. Acesta este un bun exerciţiu pentru dezvoltatorul care intră pentru prima dată în contact cu Java ME Embedded 8. Astfel, ne propunem să creăm o simplă aplicaţie, care afişează în consolă un mesaj la pornirea aplicaţiei şi unul la oprirea acesteia.

În primul rând, creăm o clasă care extinde javax.microedition.midlet.MIDlet, implementând metodele startApp() şi destroyApp(boolean unconditional):

public class Hello extends javax.microedition.midlet.MIDlet {
    public void startApp() {
        System.out.println("Hello MIDlet");
    }
    public void destroyApp(boolean unconditional) {
        System.out.println("Goodbye MIDlet");
    }
}

Pentru a continua în aceeaşi manieră, compilăm manual clasa pe care tocmai am scris-o, cu o comandă similară celei listată aici:

javac -cp %JAVA_ME_SDK%\lib\meep_8.0.jar -d classes src\ro\leje\Hello.java

Observăm că avem nevoie de biblioteca meep_8.0.jar la compilare, întrucât aceasta defineşte clasa abstractă MIDlet. Această bibliotecă se găseşte în directorul %JAVA_ME_SDK%\lib, unde %JAVA_ME_SDK% reprezintă calea unde a fost instalat SDK-ul.

Următorul pas îl reprezintă crearea fişierului manifest, care trebuie să conţină cel puţin următoarele informaţii:

MIDlet-Name: Hello
MIDlet-Version: 1.0
MIDlet-Vendor: Today Software Magazine
MIDlet-1: Hello,,ro.leje.Hello
MicroEdition-Configuration: CLDC-1.8
MicroEdition-Profile: MEEP-8.0

Presupunând că am salvat fişierul manifest cu numele MANIFEST.MF, putem trece la următorul pas, care este crearea arhivei JAR. Această arhivă trebuie să conţină clasa compilată şi fişierul manifest. Realizăm aceasta lansând în execuţie următoarea comandă:

jar cfm build\Hello.jar MANIFEST.MF -C classes .

Odată ce am creat fişierul Hello.jar, pentru această aplicaţie mai avem nevoie de un singur lucru, şi anume descriptorul aplicaţiei, cunoscut şi sub numele de fişier JAD (Java Application Descriptor). Acesta se aseamănă cu fişierul manifest, conţinând următoarele linii obligatorii:

MIDlet-Name: Hello
MIDlet-Version: 1.0
MIDlet-Vendor: Today Software Magazine
MIDlet-1: Hello,,ro.leje.Hello
MIDlet-Jar-Size: 1076
MIDlet-Jar-URL: Hello.jar
MicroEdition-Profile: MEEP-8.0

Observăm că unul dintre atributele obligatorii ale fişierului JAD este dimensiunea în bytes a arhivei. Salvăm acest fişier cu numele Hello.jad în acelaşi director cu arhiva JAR.

Rularea aplicaţiei cu un emulator

În acest moment avem o aplicaţie Java ME Embedded 8 completă, pe care o putem lansa în execuţie. Cea mai simplă modalitate pentru a face acest lucru este folosirea emulator-ului pe care ni-l pune la dispoziţie SDK-ul. Presupunând că am adăugat în PATH calea %JAVA_ME_SDK%\bin şi că directorul curent este directorul build al proiectului nostru, putem lansa următoarea comandă:

emulator -Xdevice:EmbeddedDevice1 -Xdescriptor:Hello.jad

Cu ajutorul opţiunii -Xdevice specificăm numele dispozitivului pe care dorim să rulăm aplicaţia. EmbeddedDevice1 este un dispozitiv emulat, configurat automat în momentul în care instalăm SDK-ul. Cea de-a doua opţiune prezentă în comanda pe care am executat-o este -Xdescriptor, prin intermediul căreia specificăm locaţia şi numele descriptorului aplicaţiei noastre.

Putem observa rezultatul rulării aplicaţiei în următoarea figură:

Aplicaţia Hello în emulator

Mesajul Hello MIDlet este afişat la pornirea MIDlet-ului, iar mesajul Goodbye MIDlet la oprirea acestuia, cu ajutorul combinaţiei de taste Ctrl + C.

Rularea aplicaţiei pe dispozitiv

O altă modalitate de a rula aplicaţia este prin instalarea acesteia pe dispozitivul ţintă. Pentru acest articol am folosit o plăcuţă de dezvoltare Raspberry PI Model B+, dotată cu un dongle Wi-Fi. De asemenea, menţionăm faptul că platforma are deja instalat un sistem de operare Linux, ceea ce facilitează munca noastră cu acest hardware. Având această configuraţie la îndemână putem accesa de la distanţă sistemul Raspberry PI, cu ajutorul unui program precum PuTTY.

Accesăm plăcuţa cunoscându-i IP-ul şi un user cu drepturi de root. Odată ce ne-am autentificat, schimbăm directorul curent, pentru a ne situa în directorul bin al distribuţiei Java ME Embedded 8 instalată. Acest lucru este ilustrat în următoarea captură de ecran:

Accesarea plăcuţei de dezvoltare cu PuTTY

Figura ne arată faptul că următorul pas a fost rularea script-ului usertest.sh cu ajutorul comenzii sudo ./usertest.sh. Acest script a lansat în execuţie Java runtime, care permite accesul la AMS. Platforma ascultă pe portul 2201 şi ne permite să ne conectăm de la distanţă pentru a face managementul aplicaţiilor ME.

Înainte de a putea continua, trebuie să înregistrăm dispozitivul cu ajutorul aplicaţiei Device Connections Manager. De vreme ce avem instalat SDK-ul, ar trebui să găsim în SysTray o iconiţă intitulată Oracle Java(TM) ME SDK 8.1 Device Manager. Făcând click pe aceasta, deschidem managerul de conexiuni, unde putem adăuga plăcuţa noastră, pe care o identificăm după IP. Odată ce am înregistrat dispozitivul, ar trebui să avem în fereastra activă ceva similar figurii următoare:

Înregistrarea unui dispozitiv

Acum putem instala pe Raspberry PI aplicaţia pe care am creat-o intr-o secţiune anterioară. Avem la dispoziţie câteva modalităţi pentru a face aceasta, una dintre ele fiind cu ajutorul utilitarului Device Selector, care este la dispoziţia noastră, bineînţeles, datorită faptului că am instalat SDK-ul. Deschizând această aplicaţie, observăm o listă cu toate dispozitivele instalate la momentul curent. Predefinit, avem la dispoziţie trei dispozitive emulate: EmbeddedDevice1, EmbeddedDevice2 şi QualcommIoEDevice. Alături de acestea, putem vedea plăcuţa Raspberry PI, pe care tocmai am înregistrat-o, cu numele EmbeddedExternalDevice1. Dorim să rulăm aplicaţia Hello pe acest dispozitiv, aşa că facem click-dreapta şi alegem Run JAR or JAD..., după cum este ilustrat şi în figura următoare:

Rularea aplicaţiei pe dispozitiv

Alegând de pe disk fişierul Hello.jad cu ajutorul ferestrei de tip Open care a apărut, platforma lansează în execuţie managerul de aplicaţii, care instalează pachetul nostru software pe plăcuţă, lucru pe care îl putem vedea în următoarea captură de ecran:

Managerul de aplicaţii

Faptul că aplicaţia noastră Java ME Embedded 8 rulează într-adevăr pe dispozitiv ni-l demonstrează consola PuTTY, unde putem vedea output-ul pornirii şi opririi aplicaţiei:

Output-ul aplicaţiei în consolă

Observăm faptul că în captura de ecran anterioară este listat şi mesajul care trebuie afişat la distrugerea aplicaţiei. Aceasta pentru că înainte de a face captura am apăsat butonul Remove, prezent în interfaţa aplicaţiei de management.

Aşadar, oricare ar fi modalitatea aleasă pentru a rula aplicaţii Java ME Embedded 8 fie pe dispozitive, fie într-un emulator, acesta este un proces relativ facil. Mai există o cale de a rula aplicaţii embedded pe dispozitive, cu ajutorul liniei de comandă AMS, prin intermediul utilitarului Developer Agent, însă această metodă este în fază de concept în această versiune a platformei.

Pe parcursul acestui articol am urmărit paşii creării, instalării şi rulării unei aplicaţii minimale, efectuând manual fiecare sarcină. Totuşi, platforma ne pune la dispoziţie o serie de unelte care vin în întâmpinarea nevoilor dezvoltatorilor şi ţintesc sporirea productivităţii acestora. Într-un articol viitor ne propunem să prezentăm procesul dintr-o altă perspectivă, automatizat cu ajutorul acestor unelte.

Concluzii

Dezvoltarea aplicaţiilor Java ME Embedded 8 poate fi un proces interesant şi distractiv, dar uneori dificil şi frustrant. Din păcate, materialele de studiu dedicate Java ME Embedded 8 sunt puţine. Până în momentul de faţă există o singură carte publicată care abordează subiectul dezvoltării aplicaţiilor Java ME Embedded 8. De asemenea, majoritatea articolelor existente pe această temă au o abordare generală, prezentând în linii mari trăsăturile acestei noi platforme. Deocamdată, thread-urile dedicate pe forumuri sunt relativ puţine, însă putem observa interesul din ce în ce mai mare al utilizatorilor, dornici să înveţe cum să folosească noua versiune. Cele mai consistente resurse pe care le avem la dispoziţie sunt ghidurile oficiale compilate de către Oracle, care pot fi descărcate de pe site-ul oficial al platformei.

Friday, November 14, 2014

Eclipse SWT: Cum se poate seta poziția caracterului "caret" într-un widget Text

Astăzi lucram cu un widget Text (org.eclipse.swt.widgets.Text) și am avut nevoie să setez manual poziția caret-ului după un apel al metodei setText().
Am descoperit în Javadoc metoda getCaretPosition(), care returnează un int, însă API-ul nu oferă și o metodă setCaretPosition().
Căutând pe Internet soluții la problema mea, am găsit post-uri despre cum se poate muta caret-ul la sfârșitul textului, folosind metoda setSelection(int start):

textWidget.setSelection(textWidget.getText().length());

unde textWidget este o instanță a clasei Text. Pentru mai multe detalii, vezi post-ul de pe StackOverflow.
De asemenea, API-ul ofera o variantă overloaded a metodei setSelection(int start), sub forma setSelection(int start, int end), indecșii start și end corespunzând poziției caret-ului.
Astfel, am scris următoarea soluție:

int caretPosition = textWidget.getCaretPosition();
textWidget.setText( newValue );
textWidget.setSelection( caretPosition, caretPosition );

Prin acest truc am setat poziția caret-ului la valoarea anterioară apelului metodei setText(), stabilind o selecție vidă.
Încă nu mi-e clar dacă simplul fapt că am fost nevoit să resetez manual poziția caret-ului indică un design defectuos sau nu, dar sper să revin cu un răspuns.

Monday, October 10, 2011

Subversion + Eclipse (Partea intai)

Zilele astea am avut prima experienta cu Subversion, dupa ce m-am hotarat ca e timpul sa-mi instalez si eu un sistem de control al versiunilor. Cu ceva timp in urma am citit putin despre asta si am aflat ca Subversion ar fi un produs potrivit pentru ce am eu nevoie.

De ceva timp simteam nevoia sa fac backup destul de des unui proiect personal, care s-a nascut din dorinta de a invata ceva nou. Dar backup-ul manual e ceva copilaresc in zilele noastre, asa ca in weekendul asta mi-am luat inima in dinti si am inceput sa caut cum se instaleaza si configureaza un server Subversion si apoi, cum se foloseste minunatia asta impreuna cu Eclipse. Cautand, am aflat de Subclipse, un plugin care realizeaza integrarea de care aveam nevoie.

Voi descrie in continuare pasii pe care i-am urmat pentru a instala Subversion, Subclipse si cum mi-am importat proiectul in Subversion. Pentru toate astea am pus cap la cap niste articole excelente, pe care nu le-am gasit chiar asa de greu. Voi adauga la sfarsitul articolului linkurile catre paginile de unde m-am inspirat.
  
Mai intai de toate, am descarcat Subversion in varianta ZIP. 
La adresa http://subversion.apache.org/packages.html se gasesc mai multe posibilitati de a descarca Subversion. Eu am ales din sectiunea pentru Windows, Win32Svn (32-bit client, server and bindings, MSI and ZIPs; maintained by David Darj).

Dupa ce am despachetat arhiva intr-un loc convenabil de pe hard-disk (ex. c:\svn-win32-1.6.17), am setat o variabila de sistem cu numele SVN_HOME.

(variabilele de sistem se seteaza astfel: Click-dreapta pe My Computer -> Properties -> Advanced -> Environment Variables -> System Variables -> New)

Variabila mea contine calea spre directorul care contine distributia de Subversion (ex. SVN_HOME = c:\svn-win32-1.6.17). Apoi, am pus in Path calea spre directorul bin al distributiei de Subversion (cunoscut si sub numele de SVN). Lucrul asta l-am facut astfel: am selectat variabila de sistem Path si am apasat Edit. La sfarsitul sirului, am adaugat un caracter ; (punct si virgula), iar apoi am scris: %SVN_HOME%\bin. Dupa confirmarea prin intermediul butonului OK, am putut folosi comenzile specifice Subversion, oricare ar fi fost directorul curent in Command Prompt.

Apoi am deschis linia de comanda si am creat un nou "repository" astfel: 
   svnadmin create "c:\svn-win32-1.6.17\repository"

In interiorul noului director repository exista un director numit conf. De aici am deschis svnserve.conf si am decomentat liniile care contineau:
   anon-access = none
   auth-access = write
   password-db = passwd
Apoi am adaugat un nume de utilizator si o parola corespunzatoare in fisierul passwd din acelasi director conf.
Ca Subversion sa fie intotdeauna disponibil, l-am instalat ca serviciu Windows, care sa porneasca de fiecare data cand porneste sistemul 
de operare. Am rulat comanda: 
   sc create svnserver binpath= "c:\svn-win32-1.6.17\bin\svnserve.exe --service 
-r c:\svn-win32-1.6.17\repository" displayname= "Subversion" depend= Tcpip start= auto 
Fiindca nu era pornit inca serviciul, am rulat comanda: 
   net start svnserver
Acum avem un server Subversion functional. Continuarea povestii va veni in urmatorul articol.
Asa cum am promis, iata articolele din care m-am inspirat: