Wystarczy wejść na stronę promocji  i podać maila którego mamy skonfigurowanego na naszym urządzeniu (ten sam mail z którego korzystamy w Google Play). Licencja jest dożywotnia, na wszystkie urządzenia powiązane z naszym kontem.

Ja już skorzystałem :).

W sumie to dopiero po publikacji ostatniej wersji, liczba pobrań zaczęła zauważalnie i regularnie rosnąć. Jakie zmiany przyniosła? Przede wszystkim doszła pełna obsługa logbooków (dodawanie logów i wysyłanie ich po połączeniu z internetem, ocenianie skrzynek, dodawanie własnych notatek etc).

Szczerze mówiąc, pisząc pierwsze linijki tej aplikacji, nie spodziewałem się, że kiedykolwiek ktokolwiek poza mną będzie z niej korzystał :). Muszę przyznać, że miło jest zobaczyć, jak bardzo się myliłem ;). Takie "wyniki" motywują do dalszej pracy nad projektem (a jeszcze bardziej motywują pozytywne komentarze i oceny w Google Play, więc jeżeli używasz OCFun to wiesz co masz zrobić ).

Dodawanie zależności

Po pierwsze- dodawanie nowych bibliotek jest teraz bajecznie proste. Szukamy interesującej nas biblioteki w interesującej nas wersji na mvnrepository.com i po prostu dodajemy znaleziony tam odpowiedni wpis w dependencies w naszym pliku pom.xml.

Biblioteka zostanie automatycznie pobrana i dołączona do projektu przy następnym wywołaniu mvn clean install. Co więcej, zostanie ona skopiowana do naszego lokalnego repo, dzięki czemu przy kolejnych buildach, albo gdy będziemy ją chcieli dołączyć do następnego projektu, nie będziemy jej już pobierać z internetu.

Na przykład aby dodać do naszego projektu genialną bibliotekę joda-time w najnowszej wersji, doklikamy się w końcu na stronę mvnrepository.com/artifact/joda-time/joda-time/2.3, a tam znajdziemy:

<dependency>
	<groupId>joda-time</groupId>
	<artifactId>joda-time</artifactId>
	<version>2.3</version>
</dependency>

Wklejamy to do naszego pom.xml pomiędzy tagi dependencies i gotowe- w IDE wystarczy dać 'reimport maven project' a biblioteka zostanie dołączona i będziemy mogli z niej korzytać.

I wszystko byłoby pięknie, ale... co zrobić, jeśli nie możemy znaleźć biblioteki której potrzebujemy w oficjalnym repo mavena?

Ręczne dodawanie bibliotek do lokalnego repozytorium mavena

Musimy sami dodać taką bibliotekę do lokalnego repozytorium. Są na to 3 sposoby:

• jeśli biblioteka jest projektem mavenowym i rozpowszechniana jest wraz ze źródłami- wystarczy wejść do katalogu z biblioteką, wydać z konsoli mvn clean install i już mamy ją w naszym lokalnym repo. Możemy ją "zlokalizować" używając groupId, artifactId i version z pliku pom.xml biblioteki.
• jeśli biblioteka jest rozpowszechniana ze źródłami, ale nie jest projektem mavenowym- tutaj sprawa jest cięższa, możemy spróbować zmienić ją w projekt mavenowy i postąpić tak jak w przypadku 1), ale wymaga to jako-takiej znajomości mavena, szczególnie jeśli biblioteka sama posiada jakieś zależności. Łatwiej potraktować ją tak jak w pkt 3).
• jeśli biblioteka rozpowszechniana jest jako binarka (jar, apk, cokolwiek)- tu nie mamy dużego wyboru, pozostaje nam "ręcznie" zainstalować daną binarkę w naszym repo. Służy do tego polecenie

  mvn install:install-file 
      -Dfile=sciezka\do\pliku.jar 
      -DgroupId=com.glowny.pakiet
      -DartifactId=nazwa 
      -Dversion=wersja 
      -Dpackaging=jar
  

  Oczywiście "namierzamy ją" w swoim pom.xml używając podanego tu pakietu, nazwy i wersji.

Automatyczna zmiana ustawień/konfiguracji

Jeżeli trzymamy konfiguracje naszej aplikacji w plikach .properties (a jeśli nie- to powinniśmy), to możemy zautomatyzować zmianę tej konfiguracji w zależności od profilu w jakim budujemy aplikację. Przydatne, jeśli w aplikacji korzystamy z jakiegoś serwera/konta/kluczy api, które mają wersję testową i produkcyjną.

Wystarczy, że w pliku .properties zamiast standardowego

wlasciwosc=wartosc

wpiszemy takiego potworka:

wlasciwosc=${klucz}

a w naszym pom.xml dodamy do tagu project tag properties a w nim

<klucz>wartosc</klucz>

a w tagu build dodamy tag resources a w nim

<resource>
	<directory>src/main/resources</directory>
	<filtering>true</filtering>
</resource>

to przy budowaniu, klucz zostanie automatycznie zamieniony na wartość. Droga na około? Skądże! Przydatność tego rozwiązania widać dopiero gdy dodamy do niego profile. Do tagu project należy dodać

<profiles>
        <profile>
            <id>development</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <properties>
                <klucz1>wartosc dla dev 1</klucz1>
                <klucz2>wartosc dla dev 2</klucz2>
            </properties>
        </profile>

        <profile>
            <id>release</id>
            <properties>
                <klucz1>wartosc dla releasu 1</klucz1>
                <klucz2>wartosc dla releasu 2</klucz2>
            </properties>
        </profile>
</profiles>

Teraz domyślnie przy mvn clean install używane będą wartości z profilu development (oraz te które zadeklarowaliśmy wcześniej, a nie zostały nadpisane w tym profilu). Aby użyć wartości z profilu release wystarczy wykonać mvn clean install -Prelease.

Maven android plugin

Wszystko co pokazałem do tej pory to tak naprawdę podstawowe użycie mavena. Używając androidowego pluginu do mavena, możemy osiągnąć znacznie więcej.

Deployowanie

Wydając komendę mvn android:deploy zainstalujemy naszą aplikację na wszystkich dostępnych urządzeniach i emulatorach. Możemy oczywiście zbudować i zdeployować aplikację za jednym zamachem: mvn clean install android:deploy.

Podpisywanie

Możemy podpisać naszą aplikację naszym kluczem, tak żeby była gotowa do publikacji w google play. Należy w tym celu dodać konfigurację pluginu jar-signer:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jarsigner-plugin</artifactId>
    <version>1.2</version>
    <executions>
        <execution>
            <id>signing</id>
            <goals>
                <goal>sign</goal>
            </goals>
            <phase>package</phase>
            <inherited>true</inherited>
            <configuration>
                <archiveDirectory></archiveDirectory>
                <includes>
                    <include>target/*.apk</include>
                </includes>
                <keystore>sciezka/do/pliku/keystore</keystore>
                <storepass>haslo do keystora</storepass>
                <keypass>haslo klucza</keypass>
                <alias>nazwa klucza</alias>
                <arguments>
                    <argument>-sigalg</argument>
                    <argument>MD5withRSA</argument>
                    <argument>-digestalg</argument>
                    <argument>SHA1</argument>
                </arguments>
            </configuration>
        </execution>
    </executions>
</plugin>

Oczywiście możemy całość skonfigurować tak, żeby podpisywanie odbywało się tylko kiedy budujemy aplikację w profilu release. Mamy również możliwość automatycznej aktualizacji AndroidManifest.xml na podstawie ustawień z pom.xml (w tym automatyczne podbijanie wersji co build). Nie będę już tego opisywać, wszystko to można łatwo znaleźć w dokumentacji, zamieszczę jeszcze tylko "żywy przykład" wykorzystania tych dobroci w moim projekcie OCFun.

Przykład

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <properties>
        <version>0.7.0.0</version>

        <okapiOauthSecret>oauth secret</okapiOauthSecret>
        <okapiOauthKey>oauth key</okapiOauthKey>
        <debugMapsApiKey>debug maps api key</debugMapsApiKey>
        <!-- You won't need these if you are just running the app in emulator or on your own device -->
        <releaseMapsApiKey>release maps api key</releaseMapsApiKey>
        <keystorePath>path/to/keystore</keystorePath>
        <keystorePassword>keystore pass</keystorePassword>
        <keyAlias>alias</keyAlias>
        <keyPassword>key pass</keyPassword>
        <!-- You probably don't want to change these -->
        <sdk>19</sdk>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zeyomir.ocfun</groupId>
    <artifactId>ocFun</artifactId>
    <version>${versionName}</version>
    <packaging>apk</packaging>
    <name>OpenCachingFun</name>

    <dependencies>
        <dependency>
            <groupId>android</groupId>
            <artifactId>android</artifactId>
            <version>4.4_r1</version>
            <scope>provided</scope>
        </dependency>

        <!-- Make sure this is below the android dependencies -->
        <dependency>
            <groupId>com.google.android.maps</groupId>
            <artifactId>maps</artifactId>
            <version>19_r1</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.holoeverywhere</groupId>
            <artifactId>library</artifactId>
            <version>1.4.2</version>
            <type>apklib</type>
        </dependency>

        <dependency>
            <groupId>oauth.signpost</groupId>
            <artifactId>signpost-core</artifactId>
            <version>1.2.1.2</version>
        </dependency>
        <dependency>
            <groupId>oauth.signpost</groupId>
            <artifactId>signpost-commonshttp4</artifactId>
            <version>1.2.1.2</version>
        </dependency>
    </dependencies>

    <profiles>
        <profile>
            <id>development</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <properties>
                <versionName>${version}-SNAPSHOT</versionName>
                <incrementVersion>false</incrementVersion>
                <debuggable>true</debuggable>
                <mapsApiKey>${debugMapsApiKey}</mapsApiKey>
            </properties>
        </profile>

        <profile>
            <id>release</id>
            <properties>
                <versionName>${version}</versionName>
                <incrementVersion>true</incrementVersion>
                <debuggable>false</debuggable>
                <mapsApiKey>${releaseMapsApiKey}</mapsApiKey>
            </properties>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-jarsigner-plugin</artifactId>
                        <version>1.2</version>
                        <executions>
                            <execution>
                                <id>signing</id>
                                <goals>
                                    <goal>sign</goal>
                                </goals>
                                <phase>package</phase>
                                <inherited>true</inherited>
                                <configuration>
                                    <archiveDirectory></archiveDirectory>
                                    <includes>
                                        <include>target/*.apk</include>
                                    </includes>
                                    <keystore>${keystorePath}</keystore>
                                    <storepass>${keystorePassword}</storepass>
                                    <keypass>${keyPassword}</keypass>
                                    <alias>${keyAlias}</alias>
                                    <arguments>
                                        <argument>-sigalg</argument>
                                        <argument>MD5withRSA</argument>
                                        <argument>-digestalg</argument>
                                        <argument>SHA1</argument>
                                    </arguments>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>

                    <plugin>
                        <groupId>com.jayway.maven.plugins.android.generation2</groupId>
                        <artifactId>android-maven-plugin</artifactId>
                        <inherited>true</inherited>
                        <executions>
                            <execution>
                                <id>alignApk</id>
                                <phase>install</phase>
                                <goals>
                                    <goal>zipalign</goal>
                                </goals>
                            </execution>
                        </executions>
                        <configuration>
                            <sign>
                                <debug>false</debug>
                            </sign>
                            <zipalign>
                                <verbose>true</verbose>
                                <skip>false</skip>
                                <inputApk>${project.build.directory}/${project.artifactId}.apk</inputApk>
                                <outputApk>${project.artifactId}-aligned.apk</outputApk>
                            </zipalign>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>

    <build>
        <finalName>${project.artifactId}</finalName>
        <sourceDirectory>src/main/java</sourceDirectory>
        <plugins>
            <plugin>
                <groupId>com.jayway.maven.plugins.android.generation2</groupId>
                <artifactId>android-maven-plugin</artifactId>
                <version>3.6.0</version>
                <configuration>
                    <sdk>
                        <platform>${sdk}</platform>
                    </sdk>
                    <undeployBeforeDeploy>true</undeployBeforeDeploy>
                    <manifest>
                        <versionName>${versionName}</versionName>
                        <versionCodeAutoIncrement>${incrementVersion}</versionCodeAutoIncrement>
                        <versionCodeUpdateFromVersion>false</versionCodeUpdateFromVersion>
                        <debuggable>${debuggable}</debuggable>
                    </manifest>
                </configuration>
                <extensions>true</extensions>
                <executions>
                    <execution>
                        <goals>
                            <goal>manifest-update</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>

        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

app.versionName=${versionName}
okapi.oauthKey=${okapiOauthKey}
okapi.oauthSecret=${okapiOauthSecret}
googleMaps.apiKey=${mapsApiKey}

Bonus: debugowanie

Żeby podpiąć debugger do aplikacji uruchomionej przez mavena możemy zrobić tak jak opisano na wiki android-maven-plugin, albo (prościej) użyć przycisku 'attach debugger to android process' (przynajmniej w IntelliJ IDEA, jest w okolicach przycisku 'debug'). Jeśli potrzebujemy debugować proces uruchamiania aplikacji, należy aplikację uruchomić z adb shell. Wykonujemy w terminalu:

adb shell
am start -n com.yourapp/com.yourapp.YourActivity -D

W ten sposób aplikacja uruchomi się dopiero kiedy podłączymy się do niej z debuggerem.

W świecie Javy "serwerowej" problem zarządzania zależnościami i ogólnie pojętej konfiguracji projektu i procesu budowania został rozwiązany już dawno. Aż dziwne, że w świecie Androida rozwiązanie to jest wciąż tak słabo znane. Mowa oczywiście o mavenie (oczywiście jest tego więcej, ale maven jest chyba najbardziej znany i nim właśnie się zajmiemy).

Maven pozwala opisać w formie xmla wszystkie zależności (biblioteki) projektu, oraz daje możliwość automatycznego ich pobrania. Oprócz tego możemy w tym samym xmlu opisać w jaki sposób projekt powinien wyglądać (jakie mamy foldery i który co zawiera) i jak ma być budowany (to tak w skrócie- oczywiście możliwości ma dużo więcej, a dodając pluginy to możliwości są wręcz nieograniczone). Nie przedłużając- podam krótki przepis jak używać mavena w projektach androidowych.

Krok 1. Instalacja mavena

Żeby czegoś używać, trzeba to najpierw mieć ;). Pobieramy sobie mavena ze strony projektu. Proponuję zaciągnąć od razu 2 wersje: 3.1.1 i 3.0.5. Jest to spowodowane tym, że niestety nie wszystko jest jeszcze kompatybilne z nowszymi wersjami, a z kolei część rzeczy będzie wymagać wersji najnowszej dostępnej. Przynajmniej na początku czeka nas więc odrobina żonglowania wersjami.

Ściągnięte archiwa rozpakowujemy gdzieś na dysku. Proponuję rozpakować obok siebie w katalogach odpowiednio maven3 i maven31. Teraz musimy dodać odpowiednie zmienne środowiskowe- u mnie wygląda to tak (ja mam mavena 3.0.5, Ty na razie wskaż ścieżkę do mavena 3.1.1):

JAVA_HOME = C:\Program Files\Java\jdk1.7.0_45
M2_HOME = D:\Dev\maven
PATH += ;D:\Dev\maven\bin

Teraz otwórzmy konsolę (cmd.exe). Sprawdzamy czy możemy wywołać mavena:

C:\>mvn --version
Apache Maven 3.0.5 (r01de14724cdef164cd33c7c8c2fe155faf9602da; 2013-02-19 14:51:28+0100)
Maven home: D:\Dev\maven
Java version: 1.7.0_45, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk1.7.0_45\jre
Default locale: pl_PL, platform encoding: Cp1250
OS name: "windows 8", version: "6.2", arch: "amd64", family: "windows"

Krok 2. Konfigurujemy repozytorium (nieobowiązkowe)

Domyślnie maven będzie ściągał wszystkie biblioteki do katalogu .m2/repository w katalogu głównym użytkownika. Nie ma w tym nic złego, ja jednak wolę mieć je na osobnym dysku dzięki czemu nie muszę ściągać bibliotek od nowa po formacie ;). Możemy wymusić zmianę miejsca trzymania tego repozytorium bibliotek dodając w pliku .m2/settings.xml (tworząc go jeśli jeszcze nie istnieje) następujący snippet:

<settings>
<localRepository>D:\Dev\maven_repo</localRepository>
</settings>

Krok 3. Dodajemy biblioteki androida do naszego repo

Gdyby świat był piękny, nie potrzebowalibyśmy tego kroku. Niestety w momencie pisania tego wpisu najnowsza dostępna wersja androida to 4.4 (KitKat), a w oficjalnym repozytorium mavena nadal wisi wersja 4.1. Czy to się zmieni? Ciężko powiedzieć... na szczęście możemy sami "włożyć"  potrzebne biblioteki do naszego lokalnego repozytorium. Spokojnie, nie będziemy tego robić ręcznie :). Zrobi to za nas ten projekt. Zasadniczo wszystko jest ładnie opisane w readme, ale dla wygody opiszę proces tutaj:

1. uzupełniamy zmienne środowiskowe:

   ANDROID_HOME = D:\Dev\Android\android-sdk\sdk
   PATH += ;%ANDROID_HOME%\tools;%ANDROID_HOME%\platform-tools

2. upewniamy się, że w android-sdk\sdk\platforms mamy foldery z nazwami w stylu android-api_level, np android-19 (jeśli nie, to znaczy, że mamy starego sdk-managera, wywalamy cały folder android-sdk i ściągamy najnowszą wersję)
3. ściągamy WSZYSTKIE pakiety z androidowego sdk-managera
4. ściągamy powyższy projekt (po prawej mamy 'download zip'), rozpakowujemy, wchodzimy do tego katalogu z konsoli
5. wydajemy komendę mvn install

W tym miejscu powinniśmy zmienić zmienne systemowe tak, żeby wskazywały na mavena 3.0.5.

Krok 4A. Wygenerowanie projektu mavenowo-androidowego

Istnieje możliwość wygenerowania gotowego projektu androidowo-mavenowego. Wystarczy w konsoli wklepać to (zamieniając your.company na nazwę głównego pakietu jakiego chcemy używać oraz my-android-application na nazwę naszej aplikacji):

mvn archetype:generate
-DarchetypeArtifactId=android-quickstart
-DarchetypeGroupId=de.akquinet.android.archetypes
-DarchetypeVersion=1.0.11
-DgroupId=your.company
-DartifactId=my-android-application

więcej w tym temacie w dokumentacji.

Jest to niezły sposób, żeby szybko zobaczyć 'o co w tym wszystkim chodzi', nie jest jednak doskonały. Używa bibliotek androida z głównego repo mavena, przez co nie mamy dostępu do najnowszych wersji. Możemy to oczywiście w prosty sposób naprawić, ustawiając zależności w taki sposób jak przy zmienianiu projektu androidowego w mavenowy (krok 4B).

Krok 4B. Zmienienie zwykłego projektu androidowego w projekt mavenowy

Można by oczywiście stworzyć nowy projekt mavenowy i przekopiować do niego źródła ręcznie, ale jest to droga na około. Zmienienie naszego projektu w projekt mavenowy jest całkiem proste. Wystarczy dodać w głównym katalogu projektu plik pom.xml z poniższą zawartością:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <properties>
    <version>0.6.4.1</version>
    <sdk>19</sdk>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.zeyomir.ocfun</groupId>
  <artifactId>ocFun</artifactId>
  <version>${versionName}</version>
  <packaging>apk</packaging>
  <name>OpenCachingFun</name>
  <dependencies>
    <dependency>
      <groupId>android</groupId>
      <artifactId>android</artifactId>
      <version>4.4_r1</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>${project.artifactId}</finalName>
    <sourceDirectory>src/main/java</sourceDirectory>
    <plugins>
      <plugin>
        <groupId>com.jayway.maven.plugins.android.generation2</groupId>
        <artifactId>android-maven-plugin</artifactId>
        <version>3.6.0</version>
        <configuration>
          <sdk>
            <platform>${sdk}</platform>
          </sdk>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

A następnie usunąć niepotrzebne już pliki i foldery: libs, bin, build.xml, build.properties. Oczywiście w version, name, artifactId i groupId wstaw wartości odpowiednie dla Twojego projektu. W powyższym przykładzie wykorzystywany jest android 4.4 (api v.19)- najnowszy dostępny na dzień pisania wpisu. Powinieneś ustawić takie samo jakie masz w target sdk w swoim AndroidManifest.xml.

Co dalej?

I to tyle jeśli chodzi o podstawy- masz już wstępnie skonfigurowany projekt mavenowy. W drugiej części pokażę jak do projektu dodawać biblioteki i skąd je brać, a także bardziej zaawansowane wykorzystanie mavena i maven-android-plugin (w tym deployowanie i debugowanie na emulatorze/urządzeniu usb i generowanie podpisanych plików apk gotowych do publikowania w sklepie Google Play).

Trochę historii

Jest to pierwszy na liście certyfikatów znajomości Javy. Za czasów Sun i Java6 nazywał się SCJA6 i nie był nawet wymagany (można było podejść od razu do dużo ciekawszego i bardziej rozpoznawanego SCJP6). W moim odczuciu był kierowany raczej do studentów, którzy dzięki niemu chcieli sobie pomóc w znalezieniu pierwszej pracy.

Czasy się jednak zmieniły i wraz z przejęciem Suna przez Oracle egzamin ten stał się obowiązkowy (mam wrażenie, że przy okazji cena również poszła w górę). Niektórzy twierdzą, że lepiej zdać stare SCJP6 (bo wciąż się da), a potem podejść od razu do egzaminu na OCPJP7 jako 'uaktualnienie'- podobno wychodzi taniej. Za mój egzamin płaciła jednak firma więc nie zgłębiałem tematu.

O samym egzaminie

Na egzamin umawiamy się przez stronę pearsonvue.com. Koszt to około 800 zł ($245). Do wyboru mamy kilka centrów egzaminacyjnych w okolicy, z terminami bywa mocno różnie (raz najbliższy termin jest za pół roku, raz za tydzień). Po ustaleniu terminu, możemy go do woli przekładać (bez ograniczeń ilościowych, bez konsekwencji finansowych), byle tylko zrobić to minimum 24h przed zaplanowanym egzaminem- w przeciwnym wypadku zostanie naliczona dodatkowa opłata. Przed przystąpieniem do egzaminu należy jeszcze założyć Oracle Web Account (wszystko będzie w mailu ).

Egzamin nie ma żadnych wymagań które trzeba spełnić przed przystąpieniem do niego. Jak już pisałem- jest to pierwszy certyfikat ze ścieżki certyfikacyjnej Javy, więc nie ma żadnych egzaminów które trzeba zdać wcześniej. Nie ma też żadnego obowiązkowego szkolenia/kursu. Można przystąpić do niego 'z marszu'. Ja jednak odradzam takie rozwiązanie.

Co prawda egzamin nie jest trudny (obejmuje podstawowe części języka, podstawy dziedziczenia etc, spory nacisk kładziony jest na to co się w języku zmieniło w porównaniu do wersji 6), ale mimo wszystko szanse na zdanie go bez przygotowania oceniałbym raczej na marne. Jak zatem się przygotować? O tym za chwilę.

Do rozwiązania jest 90 pytań, w dużej części są to pytania wielokrotnego wyboru, często podchwytliwe. Jedno które utkwiło mi w pamięci (nie z egzaminu, z przygotowań) brzmiało mniej-więcej tak:

Mamy plik Main.java o podanej zawartości:

public class Main{
  public int main(String[] args){
    System.out.println("main");
  }
}

Co się stanie jeśli wydamy z konsoli polecenie

javac Main.java
java Main

a) wypisane zostanie "main"
b) nic nie zostanie wypisane
c) rzucony zostanie wyjątek (Exception)
d) żadne z powyższych.

Oczywiście metoda main jest źle zadeklarowana (powinna być statyczna i zwracać void, to nie C++), więc nie ma prawa się uruchomić. Powiecie, że w takim razie poleci wyjątek? A figa z makiem. Poleci Error ;).

Na rozwiązanie wszystkich pytań mamy 140 minut. Czasu jest akurat tyle ile potrzeba jeśli jest się przygotowanym- dłuższe zastanawianie nad kilkoma pytaniami skutkować będzie tym, że czasu nam zabraknie. Żeby zdać, należy uzyskać wynik minimum 77%.

Do dyspozycji mamy kartkę papieru i długopis, zapewnione przez centrum egzaminacyjne. Poza tym nie wolno nam mieć przy sobie niczego więcej (no, poza dowodem osobistym, który musimy okazać przed przystąpieniem do egzaminu).

Wynik możemy sprawdzić na swoim koncie Oracle po kilku godzinach. Wersję elektroniczną możemy pobrać po około 48h z portalu certview.oracle.com. Drukowaną kopię certyfikatu powinniśmy otrzymać w ciągu kilku tygodni pocztą.

Przygotowania

Opcji przygotowania się do egzaminu jest kilka. Możemy wybrać jeden z oferowanych przez Oracle typów treningu (self-study, live virtual class, training on demand, classroom training). Nie jestem w stanie nic o nich powiedzieć, oprócz tego, że wszystkie są diabelnie drogie.

Mamy też dość spory wybór książek. Ja dostałem do ręki OCA Java Programmer 7 Study Guide wydawnictwa Oracle Press i... szczerze mówiąc- zawiodłem się bardzo. W moim odczuciu książka może i pozwalała poznać wymagane zagadnienia, ale na pewno nie na poziomie pozwalającym zdać egzamin.

Sytuację ratują egzaminy próbne. Ja miałem dostęp do whizlabs.com (pewnie są też inne) i bez tego chyba bym nie zdał (a na pewno nie tak wysoko). Za przystępną cenę (jeśli dobrze pamiętam to $40) otrzymujemy zestaw testów przygotowawczych (po jednym do każdego z wymaganych zagadnień), kilka zestawów "przekrojowych" ("próbnych"), oraz materiały w formie pdfów do każdego z zagadnień. Po rozwiązaniu testu otrzymujemy dość szczegółowy opis dlaczego dana odpowiedź jest poprawna a reszta błędna, co dla mnie było właściwie najcenniejszym źródłem informacji. Podobno testy te (z whizlabs) są przygotowywane przez te same osoby co testy egzaminacyjne- i ciężko mieć co do tego wątpliwości, bo sporo pytań z tych testów powtórzyło mi się w prawie niezmienionej formie na egzaminie (!). To chyba powinno ostatecznie wszystkich przekonać ;).

Niestety nie może być zbyt różowo- trafiają się źle sformułowane pytania, zdarza się, że poprawna odpowiedź oznaczona jest jako błędna, zdarza się w końcu, że wyjaśnienia do odpowiedzi nie mają sensu. Nie zdarza się to często, ale się zdarza. I wprowadza pewien niepokój. No bo skoro był błąd w jednym miejscu to może jest ich więcej? W szczególności: może niektóre pytania za które dostałem full punktów zawierają takie błędy i tak naprawdę to nie zaznaczyłem w nich poprawnej odpowiedzi? Zmusza to do sprawdzania wszystkiego w IDE i dokumentacji... co w sumie wychodzi ostatecznie na plus ;). Warto przy okazji posprawdzać różne warianty itd, żeby w pełni zrozumieć czemu coś działa tak a nie inaczej i jak zachowa się w innych warunkach.

Ile czasu należy zabezpieczyć na przygotowanie do egzaminu? Myślę, że mając dostęp do whizlabs, wolne popołudnia i determinację, by codziennie poświęcić 1-2h czasu można się spokojnie przygotować w ciągu miesiąca. Ja robiłem testy w kółko, czytając za każdym razem wyjaśnienia (nawet do tych pytań w których podałem prawidłową odpowiedź) tak długo aż miałem 100% poprawnych odpowiedzi- wtedy dopiero brałem się za następny. Około tygodnia przed egzaminem zrobiłem powtórkę ze wszystkich testów przygotowawczych (znowu czytając wyjaśnienia i powtarzając do uzyskania 100%), po jednym dziennie, czytając również odpowiedni kawałek materiału z pdfów. Na ostatnie kilka dni zostawiłem sobie testy przekrojowe (po jednym dziennie), które znowu powtarzałem do uzyskania 100%, wczytując się w wyjaśnienia i sprawdzając każdą wątpliwość w kodzie i dokumentacji.

Co dalej?

Egzamin zdany, tym samym ścieżka certyfikacyjna otwarta. Czy będę podchodził w przyszłości do (następnego w kolejności) OCPJP7? Czas pokaże, ale myślę, że tak. Nie uważam, żeby przygotowania do egzaminu nauczyły mnie czegoś nowego w sensie przydatnego. Nie sądzę też, żeby certyfikat sprawiał, że pracodawcy będą się o mnie bić (w przeciwieństwie do certyfikatów MS, tu nie występuje efekt zbierania pokemonów ;)). Ale i tak uważam, że warto- na pewno przygotowanie się do egzaminu wymusza uporządkowanie swojej wiedzy, a posiadanie certyfikatu jest zawsze plusem- pomimo tego, że zaświadcza on jedynie, że kiedyś zakuło się sporo materiału (z którego pewnie większość już się zapomniało), a nie mówi nic o faktycznych umiejętnościach.

Nowości:
- zgodnie z zapowiedziami, od początku czerwca aplikacja jest dostępna w Google Play 
- dodany został "kompas" wskazujący drogę do skrzynki- wiem, że tego chyba najbardziej brakowało

Jeżeli ktoś jeszcze nigdy się w geocaching nie bawił to polecam pobrać apkę i zobaczyć czy są w pobliżu nas jakieś skrzynki, a potem... spróbować ich poszukać! Do takiego "próbnego" szukania nie potrzebujemy żadnego konta i jeżeli nam się nie spodoba to nie musimy się nigdzie rejestrować. A spróbować warto, bo to przednia zabawa :).

kiedy: 6 lipca 2013
gdzie: Warszawa (kampus główny UW)
cena: 0 zł

Jakby co to rejestracja jest dostępna tutaj http://2013.confitura.pl/registration.

PS: Jeśli ktoś nie da rady, to zapewne nagrania z prezentacji zostaną udostępnione na youtube- tutaj paczka nagrań z zeszłego roku.

Z innych ogłoszeń: "gdzieś" w maju można się spodziewać OCFun na google play :).

Ok, jak to dziadostwo wyłączyć? Grzebiąc trochę w sieci dowiadujemy się, że zoom na stronie można zablokować (yay!). Używa się do tego następującego meta-tagu:

<meta name="viewport" content=
"width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0" />

Jednak euforia nie trwa długo- ten tag służy do zablokowania możliwości zoomowania dla użytkownika, to domyślne zachowanie przeglądarki nadal działa. A nawet jest gorzej, bo teraz użytkownik nie ma możliwości powrotu do normalnego poziomu powiększenia.

No to może da się to wyłączyć po stronie użytkownika? Musi być przecież jakaś konfiguracja, prawda? Niestety, przecież mamy do czynienia z produktem nadgryzionego jabłka ;). A nadgryzione jabłko nie przywykło do pytania swoich użytkowników o zdanie.

W każdym razie, po dłuższej chwili przekopywania się przez zakamarki sieci znajdujemy pewien hack. Hack ten polega na ustawieniu w css:

input, select {font-size: 16px;}

I już, wszystkie kłopoty znikają. Wygląda dziwnie (w kodzie, bo wygląd w przeglądarce się nie zmienia), ale działa.

I pamiętaj- Apple zawsze wie lepiej ;).