diff options
Diffstat (limited to 'main')
58 files changed, 4549 insertions, 1376 deletions
diff --git a/main/AndroidManifest.xml b/main/AndroidManifest.xml index 17fed31..95bbe8e 100644 --- a/main/AndroidManifest.xml +++ b/main/AndroidManifest.xml @@ -179,6 +179,24 @@ <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="http" android:host="www.geocaching.com" android:pathPrefix="/seek/cache_details.aspx" /> </intent-filter> + <intent-filter> + <action android:name="android.intent.action.VIEW" /> + <category android:name="android.intent.category.DEFAULT" /> + <category android:name="android.intent.category.BROWSABLE" /> + <data android:scheme="http" android:host="opencaching.de" android:pathPrefix="/OC" /> + </intent-filter> + <intent-filter> + <action android:name="android.intent.action.VIEW" /> + <category android:name="android.intent.category.DEFAULT" /> + <category android:name="android.intent.category.BROWSABLE" /> + <data android:scheme="http" android:host="www.opencaching.de" android:pathPrefix="/OC" /> + </intent-filter> + <intent-filter> + <action android:name="android.intent.action.VIEW" /> + <category android:name="android.intent.category.DEFAULT" /> + <category android:name="android.intent.category.BROWSABLE" /> + <data android:scheme="http" android:host="www.opencaching.de" android:pathPrefix="/viewcache.php" /> + </intent-filter> </activity> <activity android:name="cgeo.geocaching.TrackableActivity" @@ -236,5 +254,11 @@ android:name=".speech.SpeechService" android:label="@string/tts_service" > </service> + <activity + android:name=".connector.oc.OCAuthorizationActivity" + android:label="@string/app_name" + android:windowSoftInputMode="stateHidden" + android:configChanges="keyboardHidden|orientation" > + </activity> </application> </manifest> diff --git a/main/build.xml b/main/build.xml index febb4ae..3d611d1 100644 --- a/main/build.xml +++ b/main/build.xml @@ -83,6 +83,12 @@ <copy file="./templates/mapsapikey.xml" todir="./res/values/" overwrite="true"> <filterset refid="build-tokens" /> </copy> + <copy file="./templates/ocde_okapi.xml" todir="./res/values/" overwrite="true"> + <filterset> + <filter token="ocde.okapi.consumer.key" value="${ocde.okapi.consumer.key}"/> + <filter token="ocde.okapi.consumer.secret" value="${ocde.okapi.consumer.secret}"/> + </filterset> + </copy> </target> <!-- diff --git a/main/project/attributes_okapi/AttrGen/.classpath b/main/project/attributes_okapi/AttrGen/.classpath new file mode 100644 index 0000000..18d70f0 --- /dev/null +++ b/main/project/attributes_okapi/AttrGen/.classpath @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="UTF-8"?> +<classpath> + <classpathentry kind="src" path="src"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/> + <classpathentry kind="output" path="bin"/> +</classpath> diff --git a/main/project/attributes_okapi/AttrGen/.project b/main/project/attributes_okapi/AttrGen/.project new file mode 100644 index 0000000..cccc238 --- /dev/null +++ b/main/project/attributes_okapi/AttrGen/.project @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>AttrGen</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.jdt.core.javabuilder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.jdt.core.javanature</nature> + </natures> +</projectDescription> diff --git a/main/project/attributes_okapi/AttrGen/.settings/org.eclipse.jdt.core.prefs b/main/project/attributes_okapi/AttrGen/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..8000cd6 --- /dev/null +++ b/main/project/attributes_okapi/AttrGen/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,11 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.6 diff --git a/main/project/attributes_okapi/AttrGen/.settings/org.eclipse.jdt.ui.prefs b/main/project/attributes_okapi/AttrGen/.settings/org.eclipse.jdt.ui.prefs new file mode 100644 index 0000000..cc7a309 --- /dev/null +++ b/main/project/attributes_okapi/AttrGen/.settings/org.eclipse.jdt.ui.prefs @@ -0,0 +1,54 @@ +eclipse.preferences.version=1 +editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true +sp_cleanup.add_default_serial_version_id=true +sp_cleanup.add_generated_serial_version_id=false +sp_cleanup.add_missing_annotations=false +sp_cleanup.add_missing_deprecated_annotations=true +sp_cleanup.add_missing_methods=false +sp_cleanup.add_missing_nls_tags=false +sp_cleanup.add_missing_override_annotations=true +sp_cleanup.add_missing_override_annotations_interface_methods=false +sp_cleanup.add_serial_version_id=false +sp_cleanup.always_use_blocks=true +sp_cleanup.always_use_parentheses_in_expressions=false +sp_cleanup.always_use_this_for_non_static_field_access=false +sp_cleanup.always_use_this_for_non_static_method_access=false +sp_cleanup.convert_to_enhanced_for_loop=false +sp_cleanup.correct_indentation=false +sp_cleanup.format_source_code=true +sp_cleanup.format_source_code_changes_only=true +sp_cleanup.make_local_variable_final=false +sp_cleanup.make_parameters_final=false +sp_cleanup.make_private_fields_final=true +sp_cleanup.make_type_abstract_if_missing_method=false +sp_cleanup.make_variable_declarations_final=false +sp_cleanup.never_use_blocks=false +sp_cleanup.never_use_parentheses_in_expressions=true +sp_cleanup.on_save_use_additional_actions=true +sp_cleanup.organize_imports=true +sp_cleanup.qualify_static_field_accesses_with_declaring_class=false +sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true +sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true +sp_cleanup.qualify_static_member_accesses_with_declaring_class=false +sp_cleanup.qualify_static_method_accesses_with_declaring_class=false +sp_cleanup.remove_private_constructors=true +sp_cleanup.remove_trailing_whitespaces=true +sp_cleanup.remove_trailing_whitespaces_all=true +sp_cleanup.remove_trailing_whitespaces_ignore_empty=false +sp_cleanup.remove_unnecessary_casts=false +sp_cleanup.remove_unnecessary_nls_tags=false +sp_cleanup.remove_unused_imports=true +sp_cleanup.remove_unused_local_variables=false +sp_cleanup.remove_unused_private_fields=true +sp_cleanup.remove_unused_private_members=false +sp_cleanup.remove_unused_private_methods=true +sp_cleanup.remove_unused_private_types=true +sp_cleanup.sort_members=false +sp_cleanup.sort_members_all=false +sp_cleanup.use_blocks=true +sp_cleanup.use_blocks_only_for_return_and_throw=false +sp_cleanup.use_parentheses_in_expressions=false +sp_cleanup.use_this_for_non_static_field_access=false +sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true +sp_cleanup.use_this_for_non_static_method_access=false +sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true diff --git a/main/project/attributes_okapi/AttrGen/build.xml b/main/project/attributes_okapi/AttrGen/build.xml new file mode 100644 index 0000000..e8426f3 --- /dev/null +++ b/main/project/attributes_okapi/AttrGen/build.xml @@ -0,0 +1,14 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<project default="create_run_jar" name="Create Runnable Jar for Project AttrGen"> + <!--this file was created by Eclipse Runnable JAR Export Wizard--> + <!--ANT 1.7 is required --> + <target name="create_run_jar"> + <jar destfile="../genattr.jar" filesetmanifest="mergewithoutmain"> + <manifest> + <attribute name="Main-Class" value="GenerateAttributes"/> + <attribute name="Class-Path" value="."/> + </manifest> + <fileset dir="bin"/> + </jar> + </target> +</project> diff --git a/main/project/attributes_okapi/AttrGen/src/GenerateAttributes.java b/main/project/attributes_okapi/AttrGen/src/GenerateAttributes.java new file mode 100644 index 0000000..725dfff --- /dev/null +++ b/main/project/attributes_okapi/AttrGen/src/GenerateAttributes.java @@ -0,0 +1,172 @@ +import java.io.File; +import java.io.FileInputStream; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; +import java.util.ArrayList; + +import javax.xml.parsers.SAXParser; +import javax.xml.parsers.SAXParserFactory; + +import org.xml.sax.Attributes; +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; +import org.xml.sax.helpers.DefaultHandler; + + +public class GenerateAttributes { + + /** + * @param args + */ + public static void main(String[] args) { + + File inFile = new File(args[0]); + InputStream inputStream; + + try { + + writeHeader(); + + inputStream = new FileInputStream(inFile); + Reader reader = new InputStreamReader(inputStream,"UTF-8"); + + InputSource is = new InputSource(reader); + is.setEncoding("UTF-8"); + + parseAttributes(is); + + writeTrailer(); + + } catch (Exception e) { + e.printStackTrace(); + } + } + + private static void writeHeader() { + System.out.print( +"// This is a generated file, do not change manually!\n" + +"\n" + +"package cgeo.geocaching.connector.oc;\n" + +"\n" + +"import java.util.HashMap;\n" + +"import java.util.Map;\n" + +"\n" + +"public class AttributeParser {\n" + +"\n" + +" private final static Map<String, Integer> attrMapDe;\n" + +" private final static Map<String, Integer> attrMapPl;\n" + +"\n" + +" static {\n" + +" attrMapDe = new HashMap<String, Integer>();\n" + +" attrMapPl = new HashMap<String, Integer>();\n" + +"\n" + +" // last header line\n"); + } + + private static void writeAttr(AttrInfo attr) { + + for(String name : attr.names) { + if (attr.oc_de_id > 0) { + System.out.println(" attrMapDe.put(\"" + name + "\", " + attr.oc_de_id + ");"); + } + if (attr.oc_pl_id > 0) { + System.out.println(" attrMapPl.put(\"" + name + "\", " + attr.oc_pl_id + ");"); + } + } + + } + + private static void writeTrailer() { + System.out.print( +" // first trailer line\n" + +"\n" + +" }\n" + +"\n" + +" public static int getOcDeId(final String name) {\n" + +"\n" + +" int result = 0;\n" + +"\n" + +" if (attrMapDe.containsKey(name)) {\n" + +" result = attrMapDe.get(name);\n" + +" }\n" + +" return result;\n" + +" }\n" + +"}\n"); + } + + private static void parseAttributes(InputSource stream) { + + try { + + SAXParserFactory factory = SAXParserFactory.newInstance(); + SAXParser saxParser = factory.newSAXParser(); + + DefaultHandler handler = new DefaultHandler() { + + AttrInfo attr; + ArrayList<String> names; + boolean readingName; + + public void startElement(String uri, String localName, + String qName, Attributes attributes) + throws SAXException { + + if (qName.equalsIgnoreCase("attr")) { + attr = new AttrInfo(); + names = new ArrayList<String>(); + } + + if (attr != null && qName.equalsIgnoreCase("opencaching")) { + if ("http://opencaching.de/".equalsIgnoreCase(attributes.getValue("site_url"))) { + attr.oc_de_id = Integer.parseInt(attributes.getValue("id")); + } else if ("http://opencaching.pl/".equalsIgnoreCase(attributes.getValue("site_url"))) { + attr.oc_pl_id = Integer.parseInt(attributes.getValue("id")); + } + } + + if (names != null && qName.equalsIgnoreCase("name")) { + readingName = true; + } + } + + public void endElement(String uri, String localName, + String qName) + throws SAXException { + + if (attr != null && qName.equalsIgnoreCase("attr")) { + attr.names = names.toArray(new String[]{}); + names = null; + writeAttr(attr); + attr = null; + } + + readingName = false; + } + + public void characters(char ch[], int start, int length) + throws SAXException { + + if (readingName) { + names.add(new String(ch, start, length)); + } + } + + }; + + saxParser.parse(stream, handler); + + + } catch (Exception e) { + e.printStackTrace(); + } + + } + + static class AttrInfo { + public int oc_de_id; + public int oc_pl_id; + public String[] names; + } + +} diff --git a/main/project/attributes_okapi/AttributeParser.java b/main/project/attributes_okapi/AttributeParser.java new file mode 100644 index 0000000..63bee77 --- /dev/null +++ b/main/project/attributes_okapi/AttributeParser.java @@ -0,0 +1,327 @@ +// This is a generated file, do not change manually! + +package cgeo.geocaching.connector.oc; + +import java.util.HashMap; +import java.util.Map; + +public class AttributeParser { + + private final static Map<String, Integer> attrMapDe; + private final static Map<String, Integer> attrMapPl; + + static { + attrMapDe = new HashMap<String, Integer>(); + attrMapPl = new HashMap<String, Integer>(); + + // last header line + attrMapDe.put("Listed at Opencaching only", 6); + attrMapDe.put("Dostępna tylko na Opencaching", 6); + attrMapDe.put("Nur bei Opencaching logbar", 6); + attrMapDe.put("Solo loggeable en Opencaching", 6); + attrMapDe.put("Loggabile solo su Opencaching", 6); + attrMapPl.put("Near a Survey Marker", 54); + attrMapPl.put("W pobliżu punktu geodezyjnego", 54); + attrMapPl.put("Whereigo Cache", 55); + attrMapPl.put("Whereigo Cache", 55); + attrMapPl.put("Whereigo Cache", 55); + attrMapDe.put("Letterbox Cache", 8); + attrMapPl.put("Letterbox Cache", 56); + attrMapDe.put("Skrzynka typu Letterbox", 8); + attrMapPl.put("Skrzynka typu Letterbox", 56); + attrMapDe.put("Letterbox (benötigt Stempel)", 8); + attrMapPl.put("Letterbox (benötigt Stempel)", 56); + attrMapDe.put("Letterbox (necesita un estampador)", 8); + attrMapPl.put("Letterbox (necesita un estampador)", 56); + attrMapDe.put("Letterbox (richiede un timbro)", 8); + attrMapPl.put("Letterbox (richiede un timbro)", 56); + attrMapPl.put("GeoHotel", 43); + attrMapPl.put("GeoHotel", 43); + attrMapPl.put("GeoHotel", 43); + attrMapPl.put("Magnetic cache", 49); + attrMapPl.put("Przyczepiona magnesem", 49); + attrMapPl.put("magnetischer Cache", 49); + attrMapPl.put("Description contains an audio file", 50); + attrMapPl.put("Opis zawiera plik audio", 50); + attrMapPl.put("Offset cache", 51); + attrMapPl.put("Offset cache", 51); + attrMapPl.put("Peilungscache", 51); + attrMapPl.put("Garmin's wireless beacon", 52); + attrMapPl.put("Beacon - Garmin Chirp", 52); + attrMapPl.put("Funksignal – Garmin Chirp", 52); + attrMapPl.put("Dead Drop USB cache", 53); + attrMapPl.put("Dead Drop USB skrzynka", 53); + attrMapDe.put("Has a moving target", 31); + attrMapDe.put("bewegliches Ziel", 31); + attrMapDe.put("Objetivo en movimiento", 31); + attrMapDe.put("Oggetto in movimento", 31); + attrMapDe.put("Webcam Cache", 32); + attrMapDe.put("Webcam Cache", 32); + attrMapDe.put("Webcam Cache", 32); + attrMapDe.put("Webcam Cache", 32); + attrMapDe.put("Other cache type", 57); + attrMapDe.put("sonstiger Cachetyp", 57); + attrMapDe.put("Otro tipo de cache", 57); + attrMapDe.put("Altro tipo di cache", 57); + attrMapDe.put("Investigation required", 54); + attrMapDe.put("Recherche", 54); + attrMapDe.put("Investigación", 54); + attrMapDe.put("Ricerca", 54); + attrMapDe.put("Puzzle / Mystery", 55); + attrMapDe.put("Rätsel", 55); + attrMapDe.put("Puzzle / Misterio", 55); + attrMapDe.put("Puzzle / Mystery", 55); + attrMapDe.put("Arithmetical problem", 56); + attrMapDe.put("Rechenaufgabe", 56); + attrMapDe.put("Problema matemático", 56); + attrMapDe.put("Problema matematico", 56); + attrMapDe.put("Ask owner for start conditions", 58); + attrMapDe.put("Startbedingungen beim Owner erfragen", 58); + attrMapDe.put("Ask owner for start conditions", 58); + attrMapDe.put("Ask owner for start conditions", 58); + attrMapPl.put("Wheelchair accessible", 44); + attrMapPl.put("Dostępna dla niepełnosprawnych", 44); + attrMapPl.put("rollstuhltauglich", 44); + attrMapDe.put("Near the parking area", 24); + attrMapDe.put("nahe beim Auto", 24); + attrMapDe.put("Cerca de un Parking", 24); + attrMapDe.put("Vicino all'area di parcheggio", 24); + attrMapPl.put("Access only by walk", 84); + attrMapPl.put("Dostępna tylko pieszo", 84); + attrMapDe.put("Long walk", 25); + attrMapDe.put("längere Wanderung", 25); + attrMapDe.put("Larga caminata", 25); + attrMapDe.put("Lunga camminata", 25); + attrMapDe.put("Swamp, marsh or wading", 26); + attrMapDe.put("sumpfig/matschiges Gelände / waten", 26); + attrMapDe.put("Pantano / terreno fangoso", 26); + attrMapDe.put("Palude o marcita", 26); + attrMapDe.put("Hilly area", 27); + attrMapDe.put("hügeliges Gelände", 27); + attrMapDe.put("Terreno montañoso", 27); + attrMapDe.put("Area collinare", 27); + attrMapDe.put("Some climbing (no gear needed)", 28); + attrMapDe.put("leichtes Klettern (ohne Ausrüstung)", 28); + attrMapDe.put("fácil de subir (sin equipo)", 28); + attrMapDe.put("Arrampicata (attrezzatura non necessaria)", 28); + attrMapDe.put("Swimming required", 29); + attrMapDe.put("Schwimmen erforderlich", 29); + attrMapDe.put("Requiere nadar", 29); + attrMapDe.put("Nuoto necessario", 29); + attrMapDe.put("Access or parking fee", 36); + attrMapDe.put("Zugangs- bzw. Parkentgelt", 36); + attrMapDe.put("Acceso o parking pagando", 36); + attrMapDe.put("Tassa di ingresso o di parcheggio", 36); + attrMapPl.put("Bikes allowed", 85); + attrMapPl.put("Dostępna rowerem", 85); + attrMapPl.put("Hidden in natural surroundings (forests, mountains, etc.)", 60); + attrMapPl.put("Umiejscowiona na łonie natury (lasy, góry, itp.)", 60); + attrMapPl.put("Historic site", 61); + attrMapPl.put("Miejsce historyczne", 61); + attrMapDe.put("Point of interest", 30); + attrMapDe.put("interessanter Ort", 30); + attrMapDe.put("Punto de interes", 30); + attrMapDe.put("Punto di interesse", 30); + attrMapDe.put("Hidden wihin enclosed rooms (caves, buildings etc.)", 33); + attrMapDe.put("in geschlossenen Räumen (Höhle, Gebäude, etc.)", 33); + attrMapDe.put("en espacios confinados (cuevas, edificios, etc)", 33); + attrMapDe.put("All'interno di stanze chiuse (caverne, edifici, ecc.)", 33); + attrMapDe.put("Hidden under water", 34); + attrMapDe.put("Im Wasser versteckt", 34); + attrMapDe.put("En el agua", 34); + attrMapDe.put("Nell'acqua", 34); + attrMapDe.put("Parking area nearby", 18); + attrMapDe.put("Parkplatz in der Nähe", 18); + attrMapDe.put("Parking cercano", 18); + attrMapDe.put("Parcheggio nei pressi", 18); + attrMapDe.put("Public transportation", 19); + attrMapDe.put("erreichbar mit ÖVM", 19); + attrMapDe.put("Transporte Público", 19); + attrMapDe.put("Trasporto pubblico", 19); + attrMapDe.put("Drinking water nearby", 20); + attrMapDe.put("Trinkwasser in der Nähe", 20); + attrMapDe.put("Agua potable en las cercanias", 20); + attrMapDe.put("Acqua potabile nei pressi", 20); + attrMapDe.put("Public restrooms nearby", 21); + attrMapDe.put("öffentliche Toilette in der Nähe", 21); + attrMapDe.put("Aseos públicos cercanos", 21); + attrMapDe.put("Bagni pubblici nei pressi", 21); + attrMapDe.put("Public phone nearby", 22); + attrMapDe.put("Telefon in der Nähe", 22); + attrMapDe.put("Teléfono Público en las cercanias", 22); + attrMapDe.put("Telefono pubblico nei pressi", 22); + attrMapDe.put("First aid available", 23); + attrMapDe.put("Erste Hilfe verfügbar", 23); + attrMapDe.put("Disponible socorro rapido", 23); + attrMapDe.put("Disponibile pronto soccorso", 23); + attrMapDe.put("Available 24/7", 38); + attrMapDe.put("rund um die Uhr machbar", 38); + attrMapDe.put("Disponible las 24 horas", 38); + attrMapDe.put("Disponibile 24 ore", 38); + attrMapDe.put("Not 24/7", 39); + attrMapPl.put("Not 24/7", 80); + attrMapDe.put("Dostępna w określonych godzinach", 39); + attrMapPl.put("Dostępna w określonych godzinach", 80); + attrMapDe.put("nur zu bestimmten Uhrzeiten", 39); + attrMapPl.put("nur zu bestimmten Uhrzeiten", 80); + attrMapDe.put("Sólo disponible a ciertas horas", 39); + attrMapPl.put("Sólo disponible a ciertas horas", 80); + attrMapDe.put("Disponibile solo in certi orari", 39); + attrMapPl.put("Disponibile solo in certi orari", 80); + attrMapDe.put("Not recommended at night", 40); + attrMapDe.put("nur tagüber", 40); + attrMapDe.put("solo por el día", 40); + attrMapDe.put("solo di giorno", 40); + attrMapPl.put("Recommended at night", 91); + attrMapPl.put("Zalecane szukanie nocą", 91); + attrMapPl.put("am besten nachts findbar", 91); + attrMapDe.put("Only at night", 1); + attrMapDe.put("nur bei Nacht", 1); + attrMapDe.put("Sólo por la noche", 1); + attrMapDe.put("Solo di notte", 1); + attrMapDe.put("All seasons", 42); + attrMapDe.put("ganzjähig zugänglich", 42); + attrMapDe.put("Todas las temporadas", 42); + attrMapDe.put("Tutte le stagioni", 42); + attrMapDe.put("Only available during specified seasons", 60); + attrMapDe.put("Nur zu bestimmten Zeiten im Jahr", 60); + attrMapDe.put("Sólo disponible durante las estaciones especificadas", 60); + attrMapDe.put("Disponibile solo in certe stagioni", 60); + attrMapDe.put("Breeding season / protected nature", 43); + attrMapDe.put("Brutsaison / Naturschutz", 43); + attrMapDe.put("Temporada de reproducción / protección de la naturaleza", 43); + attrMapDe.put("Stagione di riproduzione / natura protetta", 43); + attrMapDe.put("Available during winter", 44); + attrMapDe.put("schneesicheres Versteck", 44); + attrMapDe.put("Nieve en el escondite", 44); + attrMapDe.put("Luogo a prova di neve", 44); + attrMapDe.put("Not at high water level", 41); + attrMapDe.put("nicht bei Hochwasser oder Flut", 41); + attrMapDe.put("Compass required", 47); + attrMapPl.put("Compass required", 47); + attrMapDe.put("Potrzebny kompas", 47); + attrMapPl.put("Potrzebny kompas", 47); + attrMapDe.put("Kompass", 47); + attrMapPl.put("Kompass", 47); + attrMapDe.put("Brújula", 47); + attrMapPl.put("Brújula", 47); + attrMapDe.put("Bussola", 47); + attrMapPl.put("Bussola", 47); + attrMapPl.put("Take something to write", 48); + attrMapPl.put("Weź coś do pisania", 48); + attrMapPl.put("You may need a shovel", 81); + attrMapPl.put("Potrzebna łopatka", 81); + attrMapDe.put("Flashlight required", 48); + attrMapPl.put("Flashlight required", 82); + attrMapDe.put("Potrzebna latarka", 48); + attrMapPl.put("Potrzebna latarka", 82); + attrMapDe.put("Taschenlampe", 48); + attrMapPl.put("Taschenlampe", 82); + attrMapDe.put("Linterna", 48); + attrMapPl.put("Linterna", 82); + attrMapDe.put("Lampada tascabile", 48); + attrMapPl.put("Lampada tascabile", 82); + attrMapDe.put("Climbing gear required", 49); + attrMapDe.put("Kletterzeug", 49); + attrMapDe.put("Equipo de escalada", 49); + attrMapDe.put("Attrezzatura per arrampicata", 49); + attrMapDe.put("Cave equipment required", 50); + attrMapDe.put("Höhlenzeug", 50); + attrMapDe.put("Equipación para cuevas", 50); + attrMapDe.put("Attrezzatura per grotta", 50); + attrMapDe.put("Diving equipment required", 51); + attrMapDe.put("Taucherausrüstung", 51); + attrMapDe.put("Diving equipment", 51); + attrMapDe.put("Equipo de buceo", 51); + attrMapDe.put("Special tools required", 46); + attrMapPl.put("Special tools required", 83); + attrMapDe.put("Wymagany dodatkowy sprzęt", 46); + attrMapPl.put("Wymagany dodatkowy sprzęt", 83); + attrMapDe.put("spezielle Ausrüstung", 46); + attrMapPl.put("spezielle Ausrüstung", 83); + attrMapDe.put("Equipamiento especial", 46); + attrMapPl.put("Equipamiento especial", 83); + attrMapDe.put("Equipaggiamento speciale", 46); + attrMapPl.put("Equipaggiamento speciale", 83); + attrMapDe.put("Requires a boat", 52); + attrMapPl.put("Requires a boat", 86); + attrMapDe.put("Wymaga sprzętu pływającego", 52); + attrMapPl.put("Wymaga sprzętu pływającego", 86); + attrMapDe.put("Wasserfahrzeug", 52); + attrMapPl.put("Wasserfahrzeug", 86); + attrMapDe.put("Barca", 52); + attrMapPl.put("Barca", 86); + attrMapDe.put("Barca", 52); + attrMapPl.put("Barca", 86); + attrMapDe.put("No GPS required", 35); + attrMapDe.put("ohne GPS findbar", 35); + attrMapDe.put("Sin GPS", 35); + attrMapDe.put("Senza GPS", 35); + attrMapDe.put("Dangerous area", 9); + attrMapPl.put("Dangerous area", 90); + attrMapDe.put("Skrzynka niebezpieczna", 9); + attrMapPl.put("Skrzynka niebezpieczna", 90); + attrMapDe.put("gefährliches Gebiet", 9); + attrMapPl.put("gefährliches Gebiet", 90); + attrMapDe.put("Zona Peligrosa", 9); + attrMapPl.put("Zona Peligrosa", 90); + attrMapDe.put("Area pericolosa", 9); + attrMapPl.put("Area pericolosa", 90); + attrMapDe.put("Active railway nearby", 10); + attrMapDe.put("aktive Eisenbahnlinie in der Nähe", 10); + attrMapDe.put("Cerca del ferrocarril activo", 10); + attrMapDe.put("Ferrovia attiva nei pressi", 10); + attrMapDe.put("Cliff / Rocks", 11); + attrMapDe.put("Klippen / Felsen", 11); + attrMapDe.put("Acantilado / Rocas", 11); + attrMapDe.put("Scogliera / Rocce", 11); + attrMapDe.put("Hunting", 12); + attrMapDe.put("Jagdgebiet", 12); + attrMapDe.put("Zona de Caza", 12); + attrMapDe.put("Caccia", 12); + attrMapDe.put("Thorns", 13); + attrMapDe.put("Dornen", 13); + attrMapDe.put("Espinas", 13); + attrMapDe.put("Spine", 13); + attrMapDe.put("Ticks", 14); + attrMapDe.put("Zecken", 14); + attrMapDe.put("Garrapatas", 14); + attrMapDe.put("Zecche", 14); + attrMapDe.put("Abandoned mines", 15); + attrMapDe.put("Folgen des Bergbaus", 15); + attrMapDe.put("Mina abandonada", 15); + attrMapDe.put("Miniere abbandonate", 15); + attrMapDe.put("Poisonous plants", 16); + attrMapDe.put("giftige Pflanzen", 16); + attrMapDe.put("Planta venenosa", 16); + attrMapDe.put("Piante velenose", 16); + attrMapDe.put("Dangerous animals", 17); + attrMapDe.put("giftige/gefährliche Tiere", 17); + attrMapDe.put("Animales Peligrosos", 17); + attrMapDe.put("Animali pericolosi", 17); + attrMapPl.put("Quick cache", 40); + attrMapPl.put("Szybka skrzynka", 40); + attrMapDe.put("Overnight stay necessary", 37); + attrMapDe.put("Übernachtung erforderlich", 37); + attrMapDe.put("Necesario pernoctar", 37); + attrMapDe.put("Necessario pernottamento", 37); + attrMapPl.put("Take your children", 41); + attrMapPl.put("Można zabrać dzieci", 41); + attrMapDe.put("Suited for children (10-12 yo)", 59); + attrMapDe.put("kindgerecht (10-12 Jahre)", 59); + attrMapDe.put("Apto para niños (10-12 años)", 59); + attrMapDe.put("Suited for children (10-12 anni)", 59); + // first trailer line + + } + + public static int getOcDeId(final String name) { + + int result = 0; + + if (attrMapDe.containsKey(name)) { + result = attrMapDe.get(name); + } + return result; + } +} diff --git a/main/project/attributes_okapi/attributes.xml b/main/project/attributes_okapi/attributes.xml new file mode 100644 index 0000000..ede81a8 --- /dev/null +++ b/main/project/attributes_okapi/attributes.xml @@ -0,0 +1,1940 @@ +<!-- + +Current status: WORKING DRAFT + +This is the list of all geocache attributes supported by OKAPI. In +practise, it will usually include any atribute used by at least one of +the Opencaching installations. + + +NOTES FOR EXTERNAL APP DEVELOPERS +================================= + +DO NOT read or parse this file in your apps! It is NOT guaranteed to stay +backward-compatible. Use public OKAPI methods instead. + + +NOTES FOR OC/OKAPI DEVELOPERS +============================= + +Every OC installation has its own set of internal attributes. This file +allows them to be merged with other attributes from other OC installations. +It is periodically read by every OKAPI installation, *directly from +the repository*. + +This file defines the mapping between: + +1. Internal attribute IDs of various Opencaching nodes. +2. Groundspeak's attribute IDs (used by geocaching.com). +3. OKAPI's attribute IDs. + +Important: This is a verbose, many-to-many, optional relationship! Crow's foot +notation: http://i.imgur.com/cNGz1xt.png. All those attributes may appear not +very useful when provided this way, but there is nothing OKAPI can do about it. +We leave the UI clarity problem for app developers. + +--> + +<xml> + + <!-- Language forms - status: just an idea, unimplemented (see form="" + attributes in <attr> elements). TODO: fill missing form="" attributes. --> + + <form id="is / not is"> + <prefix lang="en"> + <include><b>Include</b> the cache, only if it is:</include> + <exclude><b>Exclude</b> the cache if it is:</exclude> + </prefix> + <prefix lang="pl"> + <include><b>Uwzględnij</b> skrzynkę, tylko jeśli jest:</include> + <exclude><b>Pomiń</b> skrzynkę, jeśli jest:</exclude> + </prefix> + </form> + + <form id="contains / does not contain"> + <prefix lang="en"> + <include><b>Include</b> the cache, only if it contains:</include> + <exclude><b>Exclude</b> the cache if it contains:</exclude> + </prefix> + <prefix lang="pl"> + <include><b>Uwzględnij</b> skrzynkę, tylko jeśli zawiera:</include> + <exclude><b>Pomiń</b> skrzynkę, jeśli nie zawiera:</exclude> + </prefix> + </form> + + <form id="allowed / not allowed"> + <prefix lang="en"> + <include>The following <b>must be allowed</b>:</include> + <exclude>The following <b>may not be allowed</b>:</exclude> + </prefix> + </form> + + <form id="required / not required"> + <prefix lang="en"> + <include>The following <b>must be required</b>:</include> + <exclude>The following <b>may not be required</b>:</exclude> + </prefix> + </form> + + <form id="if / if not"> + <prefix lang="en"> + <include>The following <b>must be true</b>:</include> + <exclude>The following <b>may not be true</b>:</exclude> + </prefix> + </form> + + <!-- + + NOTICE: Categories are currently NOT implemented. In particular, the + attr[categories] is ignored. See issue 70. + + <category id="de-cache-types"> + <name lang="en">TODO</name> + </category> + + <category id="de-location"> + <name lang="en">TODO</name> + </category> + + <category id="de-facilities"> + <name lang="en">TODO</name> + </category> + + <category id="de-time-and-seasons"> + <name lang="en">TODO</name> + </category> + + <category id="de-tools"> + <name lang="en">TODO</name> + </category> + + <category id="de-dangers"> + <name lang="en">TODO</name> + </category> + + <category id="de-rating"> + <name lang="en">TODO</name> + </category> + + <category id="de-preconditions"> + <name lang="en">TODO</name> + </category> + + <category id="de-accessibility"> + <name lang="en">TODO</name> + </category> + + --> + + <attr okapi_attr_id="oconly" categories="de-listing" form="is / is not"> + <opencaching site_url="http://opencaching.de/" id="6" /> + <name lang="en">Listed at Opencaching only</name> + <desc lang="en"> + This geocache is listed at Opencaching only. + </desc> + <name lang="pl">Dostępna tylko na Opencaching</name> + <desc lang="pl"> + Skrzynka "jednosystemowa", dostępna jedynie poprzez serwis Opencaching. + </desc> + <name lang="de">Nur bei Opencaching logbar</name> + <desc lang="de"> + Der Geocache ist nur bei Opencaching gelistet. Benutzer anderer + Geocache-Datenbanken haben so einen schnellen Überblick, welche Geocaches + es sich lohnt näher anzusehen. + </desc> + <name lang="es">Solo loggeable en Opencaching</name> + <desc lang="es"> + Este geocachee esta publicado sólo en Opencaching. Este atributo permite + a los usuarios de otras plataformas encontrar rápidamente caches + interesantes de calidad OC geocaching. + </desc> + <name lang="it">Loggabile solo su Opencaching</name> + <desc lang="it"> + Questa geocache è pubblicata solo su Opencaching. Questo attributo permette + agli utenti di altre piattaforme di geocaching di trovare velocemente + interessanti cache OC di qualità. + </desc> + </attr> + + <attr okapi_attr_id="near-survey-marker" categories="de-cache-types" form="is / is not"> + <opencaching site_url="http://opencaching.pl/" id="54" /> + <name lang="en">Near a Survey Marker</name> + <desc lang="en"> + The cache is hidden in near proximity of a survey marker (also known + as geodetic marks). + </desc> + <name lang="pl">W pobliżu punktu geodezyjnego</name> + <desc lang="pl"> + Skrzynka ukryta w pobliżu punktu geodezyjnego. + <a href='http://wiki.opencaching.pl/index.php/Benchmark'>Więcej informacji</a>. + </desc> + </attr> + + <attr okapi_attr_id="wherigo" categories="de-cache-types" form="is / is not"> + <opencaching site_url="http://opencaching.pl/" id="55" /> + <name lang="en">Whereigo Cache</name> + <desc lang="en"> + Cache description includes a file - the Whereigo cartridge. In order to + find the cache, you need to download the file and install it on + a proper compatible device. + </desc> + <name lang="pl">Whereigo Cache</name> + <desc lang="pl"> + Opis skrzynki zawiera scenariusz WIGO (ang. Whereigo). Aby móc zdobyć skrzynkę + należy pobrać scenariusz i wgrać go do kompatybilnego z nim urządzenia. + <a href='http://wiki.opencaching.pl/index.php/Wherigo_czyli_Scenariusze_WIGO'>Więcej informacji</a>. + </desc> + <name lang="de">Whereigo Cache</name> + </attr> + + <attr okapi_attr_id="letterbox" categories="de-cache-types" form="is / is not"> + <opencaching site_url="http://opencaching.pl/" id="56" /> + <opencaching site_url="http://opencaching.de/" id="8" /> + <name lang="en">Letterbox Cache</name> + <desc lang="en"> + There is a stamp in the cache for stamping your personal logbook, and the + cache’s logbook will be stamped with your personal stamp. Take care not + to mix up stamps and to leave the cache’s stamp in the cache! + </desc> + <name lang="pl">Skrzynka typu Letterbox</name> + <desc lang="pl"> + W skrzynce znajduje się pieczątka, której nie można zabrać ze sobą. + Możesz jej użyć do ostemplowania swojego osobistego dziennika. + Logbook skrzynki powinien z kolei zostać ostemplowany Twoją własną + pieczątką. + <a href='http://wiki.opencaching.pl/index.php/Letterboxing'>Więcej informacji</a>. + </desc> + <name lang="de">Letterbox (benötigt Stempel)</name> + <desc lang="de"> + In dem Behälter vor Ort befindet sich ein Stempel, mit dem man sein + persönliches Logbuch abstempeln kann. Das Logbuch im Geocache wird + ebenfalls mit einem persönlichen Stempel signiert. Bitte achte unbedingt + darauf, dass du den Stempel aus dem Geocache nicht mitnimmst oder tauschst! + <a href='http://wiki.opencaching.de/index.php/Letterboxing'>Weitere Informationen</a>. + </desc> + <name lang="es">Letterbox (necesita un estampador)</name> + <desc lang="es"> + Hay un sello en el cache para estamparlo en su libro de registro personal, + y el libro de registro del cache será sellada con su sello personal. + ¡Tenga cuidado de no mezclar los sellos! + </desc> + <name lang="it">Letterbox (richiede un timbro)</name> + <desc lang="it"> + C'è un timbro nella cache per timbrare il tuo quaderno personale, + e il log della cache verrà timbrato con il tuo timbro personale. + Fate attenzione a non confondere i timbri e a lasciare il timbro della + cache nella cache! + </desc> + </attr> + + <attr okapi_attr_id="geohotel" categories="de-cache-types" form="is / is not"> + <opencaching site_url="http://opencaching.pl/" id="43" /> + <name lang="en">GeoHotel</name> + <desc lang="en"> + Primary purpose of the "GeoHotel" caches is to exchange trackables + (TravelBugs, GeoKretys, etc.). + </desc> + <name lang="pl">GeoHotel</name> + <desc lang="pl"> + Atrybut ten oznacza skrzynki których głównym celem jest lokowanie + w tej skrzynce różnych wędrujących rzeczy np GeoKrety, GeoLutins, + GeoFish itp. + </desc> + <name lang="de">GeoHotel</name> + </attr> + + <attr okapi_attr_id="magnet" categories="de-cache-types" form="is / is not"> + <opencaching site_url="http://opencaching.pl/" id="49" /> + <name lang="en">Magnetic cache</name> + <desc lang="en"> + This geocache is attached with a magnet. + </desc> + <name lang="pl">Przyczepiona magnesem</name> + <desc lang="pl"> + Skrzynka zawiera magnes i przymocowana jest za jego pomocą. + </desc> + <name lang="de">magnetischer Cache</name> + </attr> + + <attr okapi_attr_id="audiofile" categories="de-cache-types" form="if / if not"> + <opencaching site_url="http://opencaching.pl/" id="50" /> + <name lang="en">Description contains an audio file</name> + <desc lang="pl"> + In order to find this cache, you must listen to an audio recording, + which is attached to the cache description. + </desc> + <name lang="pl">Opis zawiera plik audio</name> + <desc lang="pl"> + Aby odnaleźć skrzynkę, należy odsłuchać plik dźwiękowy. Może on + zawierać zakodowane informacje, dźwięki otoczenia, opis dotarcia + do skrzynki. + </desc> + </attr> + + <attr okapi_attr_id="offset" categories="de-cache-types" form="is / is not"> + <opencaching site_url="http://opencaching.pl/" id="51" /> + <name lang="en">Offset cache</name> + <desc lang="pl"> + A specific type of a MultiCache. The coordinates point to a starting + point. The description contains simple instructions to follow + once you are in the starting point (usually, an azimuth and a + distance). + </desc> + <name lang="pl">Offset cache</name> + <desc lang="pl"> + Szczególny przypadek skrzynki typu multicache, składający się z + punktu startowego (określonego współrzędnymi) oraz jasnych + informacjami o sposobie dotarcia do finału (np. azymutu i + odległości). + </desc> + <name lang="de">Peilungscache</name> + </attr> + + <attr okapi_attr_id="chirp" categories="de-cache-types" form="contains / does not contain"> + <groundspeak id="60" inc="true" name="Wireless Beacon" /> + <opencaching site_url="http://opencaching.pl/" id="52" /> + <name lang="en">Garmin's wireless beacon</name> + <desc lang="en"> + Contains Garmin's wireless chirp beacon. + </desc> + <name lang="pl">Beacon - Garmin Chirp</name> + <desc lang="pl"> + Skrzynka zawiera Beacon Garmin chirp. + </desc> + <name lang="de">Funksignal – Garmin Chirp</name> + </attr> + + <attr okapi_attr_id="usb" categories="de-cache-types" form="is / is not"> + <opencaching site_url="http://opencaching.pl/" id="53" /> + <name lang="en">Dead Drop USB cache</name> + <desc lang="pl"> + The cache consists of an unmovable USB mass storage device, e.g. + fixed into a wall, curb etc. The device contains readme.txt file + with cache description and a logbook.txt file where you can log + your visit. + </desc> + <name lang="pl">Dead Drop USB skrzynka</name> + <desc lang="pl"> + Skrzynka typu USB Dead Drop. Pen-drive przymocowany lub wmurowany + w ścianę, budynek, krawiężnik itp. Aby zalogować znalezienie, należy + wpisać się do pliku logbook.txt znajdującego się w pamięci urządzenia. + <a href='http://wiki.opencaching.pl/index.php/Skrzynka_Dead_Drop'>Wiecej informacji</a>. + </desc> + </attr> + + <attr okapi_attr_id="moving" categories="de-cache-types" form="if / if not"> + <!-- This looks redundant to the 'moving cache' type, but it may also be a + moving final of a multi- or quiz cache. --> + <opencaching site_url="http://opencaching.de/" id="31" /> + <name lang="en">Has a moving target</name> + <desc lang="en"> + This geocache is moving around. For example, the owner might regularly + move the cache from one place to another, or the finders will do this + task and post new coordinates in their log entries. The owner must + update coordinates in the cache description after each move. + </desc> + <!-- TODO: "Has a" was added. --> + <name lang="de">bewegliches Ziel</name> + <desc lang="de"> + Der Geocache verändert seine Position und ist deshalb nicht immer am + gleichen Ort zu finden. Es gibt Varianten, bei denen der Geocache-Besitzer + den Geocache regelmäßig an anderen Orten versteckt, oder der Finder den + Geocache an einem neuen Ort versteckt. Danach muss der Besitzer jeweils + die Beschreibung aktualisieren. + </desc> + <name lang="es">Objetivo en movimiento</name> + <desc lang="es"> + Este geocache está en movimiento. Por ejemplo, el propietario podía mover + la caché periódicamente de un lugar a otro, o un geobuscador podría hacer + esto y ofrecer nuevos detalles en su registro. El propietario debe + actualizar las coordenadas en la descripción del cache después de cada + movimiento. + </desc> + <name lang="it">Oggetto in movimento</name> + <desc lang="it"> + Questa geocache è in muovimento. Per esempio, il proprietario potrebbe + spostare regolarmente la cache da un luogo ad un altro, o i cacher + potrebbero eseguire questa operazione e indicare nuove coordinate nel + loro log. Il proprietario deve aggiornare le coordinate nella descrizione + della cache dopo ogni mossa. + </desc> + </attr> + + <attr okapi_attr_id="webcam" categories="de-cache-types" form="is / is not"> + <opencaching site_url="http://opencaching.de/" id="32" /> + <name lang="en">Webcam Cache</name> + <desc lang="en"> + There is a webcam at the target location. You must record a webcam + picture of your visit and include it in your 'found' log entry. There + may be additional requirements like a geocaching banner on the photo. + The webcam’s address is included in the cache description. + </desc> + <name lang="de">Webcam Cache</name> + <desc lang="de"> + Am Ziel befindet sich eine Webcam, und für einen Fund muss man das Bild + der Webcam von sich selbst aufnehmen, um nachzuweisen, dass man vor Ort + war. Manche Webcam-Caches setzen auch weitere Bedingungen, z.B. einen + Geocaching-Banner auf dem Bild. Die Webadresse der Webcam ist in der + Beschreibung angegeben. + </desc> + <name lang="es">Webcam Cache</name> + <desc lang="es"> + Hay una webcam en el lugar de destino. necesidad a alguien para registrar + con un pantallazo de la imagen de la webcam de su visita e incluirlo en + el registro. Puede haber requisitos adicionales como un signo de + geocaching en la imagen. La dirección de la webcam está incluido en la + descripción de la cache. + </desc> + <name lang="it">Webcam Cache</name> + <desc lang="it"> + C'è una webcam nella posizione di destinazione. E' necessario registrare + una foto con la webcam della vostra visita e includerla nel log. Ci + possono essere requisiti addizionali come un segnale di geocaching sulla + foto. L'indirizzo della webcam è incluso nella descrizione della cache. + </desc> + </attr> + + <attr okapi_attr_id="other-type" categories="de-cache-types"> + <!-- + This looks redundant to the "unknown type" cache type, but + it is used vor special variants of basic cache types - e.g. a + multicache where you won't just find a box at the final but have + to meet an additional challenge there. + --> + <opencaching site_url="http://opencaching.de/" id="57" /> + <name lang="en">Other cache type</name> + <desc lang="en"> + This is none of the standard, pre-defined types of cache. + Use this attribute for special, unusual caches. + </desc> + <name lang="de">sonstiger Cachetyp</name> + <desc lang="de"> + Dieser Cache passt in keine der üblichen Kategorien von Caches (Cachearten). + </desc> + <name lang="es">Otro tipo de cache</name> + <desc lang="es"> + Este es un cache que no pertenece a ninguna de las categorías predefinicas + - estándar. + </desc> + <name lang="it">Altro tipo di cache</name> + <desc lang="it"> + Questa è una cache che non appartiene a nessuna delle categorie standard + perdefinite. Usa questo attributo per cache speciali e inusuali. + </desc> + </attr> + + <attr okapi_attr_id="investigation" categories="de-preconditions"> + <opencaching site_url="http://opencaching.de/" id="54" /> + <name lang="en">Investigation required</name> + <desc lang="en"> + You must investigate additional information before you can seek this cache. + </desc> + <name lang="de">Recherche</name> + <desc lang="de"> + Für diesen Cache muss vorab nach Informationen gesucht werden. + </desc> + <name lang="es">Investigación</name> + <desc lang="es"> + Necesitas encontrar más información antes de poder buscar este cache. + </desc> + <name lang="it">Ricerca</name> + <desc lang="it"> + È necessario trovare ulteriori informazioni prima di poter cercare + questa cache. + </desc> + </attr> + + <attr okapi_attr_id="puzzle" categories="de-preconditions"> + <groundspeak id="47" inc="true" name="Field puzzle" /> + <opencaching site_url="http://opencaching.de/" id="55" /> + <name lang="en">Puzzle / Mystery</name> + <desc lang="en"> + Puzzles or mysteries have to be solved before or while seeking this cache. + </desc> + <name lang="de">Rätsel</name> + <desc lang="de"> + Bei diesem Cache sind als Vorarbeit oder während der Suche Rütsel zu lösen. + </desc> + <name lang="es">Puzzle / Misterio</name> + <desc lang="es"> + Misterio o Puzzle para ser resuelto antes o durante la búsqueda de este cache. + </desc> + <name lang="it">Puzzle / Mystery</name> + <desc lang="it"> + Puzzle o Mystery devono essere risolti prima o durante la ricerca di + questa cache. + </desc> + </attr> + + <attr okapi_attr_id="maths" categories="de-preconditions"> + <opencaching site_url="http://opencaching.de/" id="56" /> + <name lang="en">Arithmetical problem</name> + <desc lang="en"> + Before or while seeking this cache, arithmetical problems must be solved + which go beyond very basic calculations. + </desc> + <name lang="de">Rechenaufgabe</name> + <desc lang="de"> + Es müssen vorab oder während der Suche Rechenaufgaben gelöst werden, die + über das kleine Geocacher 1x1 hinausgehen. zum Beispiel + Mittelpunktberechnungen oder Peilungen. + </desc> + <name lang="es">Problema matemático</name> + <desc lang="es"> + Antes o durante la búsqueda de este cache, resolver problemas matemáticos + sencillos más difícil a los cálculos de la base. + </desc> + <name lang="it">Problema matematico</name> + <desc lang="it"> + Prima o durante la ricerca di questa cache, devono essere risolti problemi + matematici più difficili di semplici calcoli base. + </desc> + </attr> + + <attr okapi_attr_id="ask-owner" categories="de-preconditions"> + <opencaching site_url="http://opencaching.de/" id="58" /> + <name lang="en">Ask owner for start conditions</name> + <desc lang="en"> + Before doing this cache, you must ask the owner for the starting conditions. + E.g. the cache may be linked to certain events at varying dates. + </desc> + <name lang="de">Startbedingungen beim Owner erfragen</name> + <desc lang="de"> + Bei diesem Cache ist es nötig, sich vor dem Angehen des Caches beim + Eigentümer über die Bedingungen zum Angehen zu informieren. + </desc> + <name lang="es">Ask owner for start conditions</name> + <desc lang="es"> + Pregunte a los propietarios por las condiciones iniciales + </desc> + <name lang="it">Ask owner for start conditions</name> + <desc lang="it"> + Chiedere al proprietario per le condizioni di partenza + </desc> + </attr> + + <attr okapi_attr_id="wheelchair" categories="de-accessibility"> + <groundspeak id="24" inc="true" name="Wheelchair accessible" /> + <opencaching site_url="http://opencaching.pl/" id="44" /> + <name lang="en">Wheelchair accessible</name> + <desc lang="en"> + The cache is hidden in a way which makes it possible to be found + when moving on a wheelchair. + </desc> + <name lang="pl">Dostępna dla niepełnosprawnych</name> + <desc lang="pl"> + Skrzynka ukryta w sposób umożliwiający jej znalezienie osobom + poruszającym się na wózku inwalidzkim. Dotyczy to zarówno + lokalizacji (np. dojazd alejką pod samą skrzynkę), jak i sposobu + ukrycia. + </desc> + <name lang="de">rollstuhltauglich</name> + </attr> + + <attr okapi_attr_id="drivein" categories="de-accessibility"> + <groundspeak id="53" inc="true" name="Park and grab" /> + <opencaching site_url="http://opencaching.de/" id="24" /> + <name lang="en">Near the parking area</name> + <desc lang="en"> + The geocache is located close to a parking area, only a few steps away. + </desc> + <name lang="de">nahe beim Auto</name> + <desc lang="de"> + Der Parkplatz befindet sich in unmittelbarer Nähe zum Geocache. + Es sind nicht mehr als einige Schritte notwendig um den Geocache zu finden. + </desc> + <name lang="es">Cerca de un Parking</name> + <desc lang="es"> + El geocache se encuentra cerca de un parking, a poca distancia. + </desc> + <name lang="it">Vicino all'area di parcheggio</name> + <desc lang="it"> + La geocache è posta vicino ad un'area di parcheggio, solo poco distante. + </desc> + </attr> + + <attr okapi_attr_id="walk-only" categories="de-accessibility"> + <opencaching site_url="http://opencaching.pl/" id="84" /> + <name lang="en">Access only by walk</name> + <desc lang="en"> + The cache is accessible by walk only. + </desc> + <name lang="pl">Dostępna tylko pieszo</name> + <desc lang="pl"> + Skrzynka dostępna tylko pieszo. + </desc> + </attr> + + <attr okapi_attr_id="hike" categories="de-accessibility"> + <groundspeak id="9" inc="true" name="Significant Hike" /> + <opencaching site_url="http://opencaching.de/" id="25" /> + <name lang="en">Long walk</name> + <desc lang="en"> + This cache requires a long walk - more than 5 km round trip. In the + mountains and other steep areas, the distance for a 'long walk' may be + shorter. Walking shoes and appropriate equipment are recommended. + </desc> + <name lang="de">längere Wanderung</name> + <desc lang="de"> + Bei diesem Cache erwartet euch eine Wanderung von mehr als 5 Kilometer, + vom Ausgangspunkt bis zum Cache und wieder zurück. Im Gebirge und bei + entsprechenden Steigungen kann das Attribut auch bei kürzeren Wegstrecken + gesetzt sein. Gute Wanderschuhe und entsprechende Ausrüstung empfehlen sich. + </desc> + <name lang="es">Larga caminata</name> + <desc lang="es"> + Esta cache requiere una larga caminata - más de 5 kilometros de ida y + vuelta. En las montañas escarpadas o en otras áreas. Recomendados calzado + para caminar y equipo adecuado. + </desc> + <name lang="it">Lunga camminata</name> + <desc lang="it"> + Questa cache richiede una lunga camminata - più di 5 km tra andata e + ritorno. In montagna o in altre aree ripide, la distanza per una cache + del genere può essere minore. Sono raccomandati scarpe da escursione ed + equipaggiamento adeguato. + </desc> + </attr> + + <attr okapi_attr_id="wading" categories="de-accessibility"> + <groundspeak id="11" inc="true" name="May require wading" /> + <opencaching site_url="http://opencaching.de/" id="26" /> + <name lang="en">Swamp, marsh or wading</name> + <desc lang="en"> + This cache requires passing swampy or marshy ground our wading throuh + shallow water. Wear appropriate clothes. After rainfall, the terrain + may be very demanding or not passable at all. + </desc> + <name lang="de">sumpfig/matschiges Gelände / waten</name> + <desc lang="de"> + Bei diesem Cache geht es durch sumpfiges oder matschiges Gelände oder + es muss durch flaches Wasser gewatet werden. Entsprechende Kleidung + wird empfohlen. Nach Regenfällen kann das Gelände wesentlich schwerer + oder überhaupt nicht begehbar sein. + </desc> + <!-- TODO: add 'wading' to Spanish translation --> + <name lang="es">Pantano / terreno fangoso</name> + <desc lang="es"> + Esta cache requiere la superación de pantanos. Usar ropa apropiada. + Después de la lluvia, el suelo puede ser difícil o no factible. + </desc> + <!-- TODO: add 'wading' to Italian translation --> + <name lang="it">Palude o marcita</name> + <desc lang="it"> + Questa cache richiede il superamento di terreno paludoso o + acquitrinoso. Indossare un abbigliamento adeguato. Dopo la pioggia, + il terreno può essere molto impegnativo o non praticabile a tutti. + </desc> + </attr> + + <attr okapi_attr_id="steep" categories="de-accessibility"> + <opencaching site_url="http://opencaching.de/" id="27" /> + <name lang="en">Hilly area</name> + <desc lang="en"> + One or more ascents lie between you and the cache. + </desc> + <name lang="de">hügeliges Gelände</name> + <desc lang="de"> + Auf dem Weg zum Geocache bzw. während der Cachesuche sind eine oder + mehrere Steigungen zu überwinden. + </desc> + <name lang="es">Terreno montañoso</name> + <desc lang="es"> + Una o más pendientes para acceder al cache. + </desc> + <name lang="it">Area collinare</name> + <desc lang="it"> + Una o più salite si trovano tra voi e la cache. + </desc> + </attr> + + <attr okapi_attr_id="climbing" categories="de-accessibility"> + <groundspeak id="10" inc="true" name="Difficult climbing" /> + <opencaching site_url="http://opencaching.de/" id="28" /> + <name lang="en">Some climbing (no gear needed)</name> + <desc lang="en"> + This cache requires some climbing and you may have to use your hands, + but you won’t need climbing gear. Be very careful during rainy weather + or before thunderstorms! + </desc> + <name lang="de">leichtes Klettern (ohne Ausrüstung)</name> + <desc lang="de"> + Während der Cachesuche ist leichtes Klettern notwendig, bei dem man sich + z.B. mit den Händen festhalten muss. Gute Trittsicherheit und + Schwindelfreiheit empfehlen sich. Es ist jedoch keine Spezialausrüstung + notwendig wie z.B. Sicherungsseil, Klettersteigset oder Steigeisen. + Besonders bei feuchter Witterung oder vor Gewittern sollte man mit der + entsprechenden Vorsicht handeln. + </desc> + <name lang="es">fácil de subir (sin equipo)</name> + <desc lang="es"> + Esta cache requiere un poco de escalada y puede ser necesario usar las + manos, pero no es necesario material de montaña. ¡Tenga mucho cuidado + durante la temporada de lluvias.! + </desc> + <name lang="it">Arrampicata (attrezzatura non necessaria)</name> + <desc lang="it"> + Questa cache richiede un po' di arrampicata e potrebbe essere necessario + usare le mani, ma non c'è bisogno di attrezzatura da arrampicata. + Prestare molta attenzione durante la stagione delle piogge o prima dei + temporali! + </desc> + </attr> + + <attr okapi_attr_id="swimming" categories="de-accessibility"> + <groundspeak id="12" inc="true" name="May require swimming" /> + <opencaching site_url="http://opencaching.de/" id="29" /> + <name lang="en">Swimming required</name> + <desc lang="en"> + This cache requires crossing a river or a lake. The water can be steep. + </desc> + <name lang="de">Schwimmen erforderlich</name> + <desc lang="de"> + Auf dem Weg zum Geocache muss ein Fluß oder See überquert werden. + Das Wasser ist tief genug um zu schwimmen. Je nach Örtlichkeit kann auch + ein Schlauchboot, Kajak oder ähnliches verwendet werden (näheres ist + in der Beschreibung zum Geocache zu finden). Die Entfernung ist aber ohne + besondere Ausdauer noch zu schwimmen. + </desc> + <name lang="es">Requiere nadar</name> + <desc lang="es"> + Esta cache requiere cruzar un río o un lago. El agua es lo suficientemente + profundo para nadar. Puede utilizar un barco, pero la distancia es lo + suficientemente corto como para ser asequible para un nadador. + </desc> + <name lang="it">Nuoto necessario</name> + <desc lang="it"> + Questa cache richiede l'attraversamento di un fiume o un lago. L'acqua è + abbastanza profonda per nuotare. È possibile utilizzare una barca, ma la + distanza è abbastanza breve per essere alla portata di un nuotatore medio. + </desc> + </attr> + + <attr okapi_attr_id="fee" categories="de-accessibility"> + <groundspeak id="2" inc="true" name="Access or parking fee" /> + <opencaching site_url="http://opencaching.de/" id="36" /> + <name lang="en">Access or parking fee</name> + <desc lang="en"> + You must pay an access or parking fee to access this cache. + </desc> + <name lang="de">Zugangs- bzw. Parkentgelt</name> + <desc lang="de"> + Um zum Cache zu gelangen, müsst ihr entweder einen Eintritt oder eine + Parkgebühr bezahlen. + </desc> + <name lang="es">Acceso o parking pagando</name> + <desc lang="es"> + Deberas pagar un acceso o estacionamiento para acceder a esta cache. + </desc> + <name lang="it">Tassa di ingresso o di parcheggio</name> + <desc lang="it"> + Devi pagare un accesso o parcheggio a pagamento per accedere a questa cache. + </desc> + </attr> + + <attr okapi_attr_id="bike" categories="de-accessibility"> + <groundspeak id="32" inc="true" name="Bicycles" /> + <opencaching site_url="http://opencaching.pl/" id="85" /> + <name lang="en">Bikes allowed</name> + <desc lang="en"> + You can reach the cache by bike. + </desc> + <name lang="pl">Dostępna rowerem</name> + <desc lang="pl"> + Można dojechać do skrzynki rowerem. + </desc> + <desc lang="de">Fahrräder erlaubt</desc> + </attr> + + <attr okapi_attr_id="nature" categories="de-location"> + <opencaching site_url="http://opencaching.pl/" id="60" /> + <name lang="en">Hidden in natural surroundings (forests, mountains, etc.)</name> <!-- i.e. not in a city? --> + <desc lang="en"> + The cache is hidden in a remote and quick place - a forest, wild + meadow, a swap, etc. + </desc> + <name lang="pl">Umiejscowiona na łonie natury (lasy, góry, itp.)</name> + <desc lang="pl"> + Umiejscowiona na łonie natury, z dala od cywilizacji - las, dzika + łąka, mokradła. + </desc> + <desc lang="de">in freier Natur versteckt</desc> + </attr> + + <attr okapi_attr_id="historic" categories="de-location"> + <opencaching site_url="http://opencaching.pl/" id="61" /> + <name lang="en">Historic site</name> + <desc lang="en"> + The cache is hidden near a historic site - a castle, battleplace, + cementary, old bunkers, etc. + </desc> + <name lang="pl">Miejsce historyczne</name> + <desc lang="pl"> + W sąsiedztwie miejsca historycznego - zamku, pałacu, pola bitwy, + cmentarza, ale także fortów czy bunkrów. + </desc> + <desc lang="de">historischer Ort</desc> + </attr> + + <attr okapi_attr_id="poi" categories="de-location"> + <opencaching site_url="http://opencaching.de/" id="30" /> + <name lang="en">Point of interest</name> + <desc lang="en"> + There is a point of interest at the cache, like a nice scenic view + or a larger castle ruin. This place is worth visiting it even + without a geocache nearby. + </desc> + <name lang="de">interessanter Ort</name> + <desc lang="de"> + Der Geocache ist in unmittelbarer Nähe zu einer Sehenswürdigkeit + versteckt. Das kann ein z.B. schüner Aussichtspunkt oder eine größere + Burgruine sein. Ein Besuch würde sich auch ohne besonderen Anlass + (den Geocache) lohnen. + </desc> + <name lang="es">Punto de interes</name> + <desc lang="es"> + Hay un monumento cerca del cache, como un paisaje hermoso o un castillo + en ruinas. Este lugar es digno de visitar, incluso sin un geocache cerca. + </desc> + <name lang="it">Punto di interesse</name> + <desc lang="it"> + C'è un punto di interesse alla cache, come un bel panorama o di un + castello in rovina. Questo luogo merita una visita anche senza una + geocache vicina. + </desc> + </attr> + + <attr okapi_attr_id="indoor" categories="de-location"> + <opencaching site_url="http://opencaching.de/" id="33" /> + <name lang="en">Hidden wihin enclosed rooms (caves, buildings etc.)</name> + <desc lang="en"> + This geocache is not hidden in the open air, but within a building, + a cave or similar. + </desc> + <name lang="de">in geschlossenen Räumen (Höhle, Gebäude, etc.)</name> + <desc lang="de"> + Das Ziel des Geocaches liegt nicht im Freien, sondern zum Beispiel in + einem Gebäude oder einer Höhle. + </desc> + <name lang="es">en espacios confinados (cuevas, edificios, etc)</name> + <desc lang="es"> + Este geocache no está al aire libre, esta oculto dentro de un edificio, + una cueva o similares. + </desc> + <name lang="it">All'interno di stanze chiuse (caverne, edifici, ecc.)</name> + <desc lang="it"> + Questa geocache non è nascosta all'aria aperta ma all'interno di un + edificio, di una grotta o simili. + </desc> + </attr> + + <attr okapi_attr_id="submerged" categories="de-location"> + <opencaching site_url="http://opencaching.de/" id="34" /> + <name lang="en">Hidden under water</name> + <desc lang="en"> + This cache or one of the stages is placed underwater. + You will get wet when doing this cache. + </desc> + <name lang="de">Im Wasser versteckt</name> + <desc lang="de"> + Der Geocache oder eine der Stationen ist im Wasser versteckt. Um die + Aufgabe zu lösen muss man ggf. das Wasser betreten, schwimmen oder tauchen. + </desc> + <name lang="es">En el agua</name> + <!-- TODO: update Spanish translation, English and German descriptions have slightly changed --> + <desc lang="es"> + Esta cache o una de sus etapas se encuentran bajo el agua. Usted debe + entrar en el agua, nadar o zambullirse. + </desc> + <name lang="it">Nell'acqua</name> + <!-- TODO: update Italian translation, English and German descriptions have slightly changed --> + <desc lang="it"> + Questa cache o uno dei suoi stadi sono posizionati sott'acqua. Devi + entrare in acqua, nuotare o fare una immersione. + </desc> + </attr> + + <attr okapi_attr_id="parking" categories="de-facilities"> + <groundspeak id="25" inc="true" name="Parking available" /> + <opencaching site_url="http://opencaching.de/" id="18" /> + <name lang="en">Parking area nearby</name> + <desc lang="en"> + A nearby parking area is situated as starting point for doing this cache. + </desc> + <name lang="de">Parkplatz in der Nähe</name> + <desc lang="de"> + Es gibt in der Nähe einen Parklplatz, der sich als Startpunkt für die + Cachesuche eignet. + </desc> + <name lang="es">Parking cercano</name> + <desc lang="es"> + Una zona de aparcamiento se encuentra cerca del punto de partida de + este cache. + </desc> + <name lang="it">Parcheggio nei pressi</name> + <desc lang="it"> + Una area di parcheggio è situata nei pressi del punto di partenza di + questa cache. + </desc> + </attr> + + <attr okapi_attr_id="public-transport" categories="de-facilities"> + <groundspeak id="26" inc="true" name="Public transportation" /> + <opencaching site_url="http://opencaching.de/" id="19" /> + <name lang="en">Public transportation</name> + <desc lang="en"> + This cache is located outside of urban areas and has a public + transport station nearby. + </desc> + <name lang="de">erreichbar mit ÖVM</name> + <desc lang="de"> + Dieser Cache lässt sich mit Hilfe von öffentlichen Verkehrsmitteln erreichen + und liegt außerhalb von Städten. + </desc> + <name lang="es">Transporte Público</name> + <desc lang="es"> + Este cache se encuentra también fuera de las zonas urbanas y una + estación de transporte público. + </desc> + <name lang="it">Trasporto pubblico</name> + <desc lang="it"> + Questa cache è situata al difuori di aree urbane e ha una stazione di + trasporto pubblico nelle vicinanze. + </desc> + </attr> + + <attr okapi_attr_id="drinking-water" categories="de-facilities"> + <groundspeak id="27" inc="true" name="Drinking water nearby" /> + <opencaching site_url="http://opencaching.de/" id="20" /> + <name lang="en">Drinking water nearby</name> + <desc lang="en"> + There is drinking water along the trail or near the cache. This may be + useful especially especially when doing event caches, longer hikes or + caches at probably dirty locations. + </desc> + <name lang="de">Trinkwasser in der Nähe</name> + <desc lang="de"> + Während der Cachetour oder in der Nähe des Geocaches ist Trinkwasser + verfügbar. Besonders bei Event-Caches, längeren Multicaches und bei + Geocaches wo man vermutlich schmutzig wird kann dies hilfreich sein. + </desc> + <name lang="es">Agua potable en las cercanias</name> + <desc lang="es"> + Hay agua potable a lo largo de la ruta o cerca de la cache. Este + atributo es especialmente útil en la planificación de Eventos, + o caches con viajes largos a lugares como las cuevas o minas + probablemente esté sucio. + </desc> + <name lang="it">Acqua potabile nei pressi</name> + <desc lang="it"> + C'è acqua potabile lungo il percorso o nelle vicinanze della cache. + Questo attributo è utile soprattutto nella pianificazione di cache + evento, di lunghe escursioni o di cache in luoghi probabilmente + sporchi come le grotte o le miniere. + </desc> + </attr> + + <attr okapi_attr_id="restrooms" categories="de-facilities"> + <groundspeak id="28" inc="true" name="Public restrooms nearby" /> + <opencaching site_url="http://opencaching.de/" id="21" /> + <name lang="en">Public restrooms nearby</name> + <desc lang="en"> + There are public restrooms along the way or near the cache. + </desc> + <name lang="de">öffentliche Toilette in der Nähe</name> + <desc lang="de"> + Während der Cachetour oder in der Nähe des Geocaches ist eine öffentliche + Toilette verfügbar. + </desc> + <name lang="es">Aseos públicos cercanos</name> + <desc lang="es"> + Hay baños públicos a lo largo de la carretera o en las proximidades + del cache. + </desc> + <name lang="it">Bagni pubblici nei pressi</name> + <desc lang="it"> + Ci sono WC pubblici lungo la strada o nelle vicinanze della cache. + </desc> + </attr> + + <attr okapi_attr_id="phone" categories="de-facilities"> + <groundspeak id="29" inc="true" name="Telephone nearby" /> + <opencaching site_url="http://opencaching.de/" id="22" /> + <name lang="en">Public phone nearby</name> + <desc lang="en"> + There is a public phone along the way or near the cache. + </desc> + <name lang="de">Telefon in der Nähe</name> + <desc lang="de"> + Während der Cachetour oder in der Nähe des Geocaches gibt es ein + öffentliches Telefon. + </desc> + <name lang="es">Teléfono Público en las cercanias</name> + <desc lang="es"> + Hay teléfonos públicos en la carretera o en las proximidades del cache. + </desc> + <name lang="it">Telefono pubblico nei pressi</name> + <desc lang="it"> + Ci sono telefoni pubblici lungo la strada o nelle vicinanze della cache. + </desc> + </attr> + + <attr okapi_attr_id="first-aid" categories="de-facilities"> + <opencaching site_url="http://opencaching.de/" id="23" /> + <name lang="en">First aid available</name> + <desc lang="en"> + There is a first aid station, call box, mountain rescue or similar + arrangement near the cache. + </desc> + <name lang="de">Erste Hilfe verfügbar</name> + <desc lang="de"> + In der Nähe des Caches findet ihr eine Erste Hilfe-Station, Notrufsäule, + Bergwacht oder entsprechende Einrichtung. + </desc> + <name lang="es">Disponible socorro rapido</name> + <desc lang="es"> + Hay un punto de socorro, un teléfono para pedir ayuda, un centro de + rescate de montaña o similar cerca del cache. + </desc> + <name lang="it">Disponibile pronto soccorso</name> + <desc lang="it"> + C'è un pronto soccorso, un telefono per chiamate di soccorso, un centro + di soccorso alpino o simili nelle vicinanze della cache. + </desc> + </attr> + + <attr okapi_attr_id="24-hours" categories="de-time-and-seasons"> + <groundspeak id="13" inc="true" name="Available at all times" /> + <opencaching site_url="http://opencaching.de/" id="38" /> + <name lang="en">Available 24/7</name> + <desc lang="en"> + This cache can be found at any time of day or week. + </desc> + <name lang="de">rund um die Uhr machbar</name> + <desc lang="de"> + Dieser Cache ist jederzeit machbar, sowohl am Tage als auch in der Nacht. + </desc> + <name lang="es">Disponible las 24 horas</name> + <desc lang="es"> + Esta cache se puede encontrar tanto de día como de noche. + </desc> + <name lang="it">Disponibile 24 ore</name> + <desc lang="it"> + Questa cache può essere trovata sia di giorno che di notte. + </desc> + </attr> + + <attr okapi_attr_id="not-24-hours" categories="de-time-and-seasons"> + <groundspeak id="13" inc="false" name="Available at all times" /> + <opencaching site_url="http://opencaching.pl/" id="80" /> + <opencaching site_url="http://opencaching.de/" id="39" /> + <name lang="en">Not 24/7</name> + <desc lang="en"> + This cache can only be done at certain times of day or week - see the cache + description for more details. For example, the cache may be placed in an + area with restricted opening hours. + </desc> + <name lang="pl">Dostępna w określonych godzinach</name> + <desc lang="pl"> + Dostępna w określonych dniach, godzinach, często wstęp płatny. + Często będzie to muzeum lub skansen. Szczegółowe informacje o + dostępności powinny znajdować się w opisie skrzynki. + </desc> + <name lang="de">nur zu bestimmten Uhrzeiten</name> + <desc lang="de"> + Dieser Cache lässt sich nur zu bestimmten Tageszeiten absolvieren. + Nähere Angaben sind in der Beschreibung des Caches zu finden. + </desc> + <name lang="es">Sólo disponible a ciertas horas</name> + <desc lang="es"> + Esta cache se puede hacer solamente en ciertos momentos del día - + véase la descripción de caché para obtener más detalles. + </desc> + <name lang="it">Disponibile solo in certi orari</name> + <desc lang="it"> + Questa cache può essere cercata solo a certe ore del giorno - + vedi la descrizione per ulteriori informazioni. + </desc> + </attr> + + <attr okapi_attr_id="daycache" categories="de-time-and-seasons"> + <groundspeak id="14" inc="false" name="Recommended at night" /> + <opencaching site_url="http://opencaching.de/" id="40" /> + <name lang="en">Not recommended at night</name> + <desc lang="en"> + Searching for this cache is not recommended by night. It might be + dangerous, or the cache may be hidden in an area where flashlights + may attract unwanted attention. + </desc> + <name lang="de">nur tagüber</name> + <desc lang="de"> + Dieser Cache lässt sich nur tagsüber angehen, zum Beispiel weil das Gelände + gefährlich ist oder die Suche mit Taschenlampen in einem Wohngebiet negativ + auffallen würde. + </desc> + <name lang="es">solo por el día</name> + <desc lang="es"> + Deberas encontrar este cache sólo durante el día. Por ejemplo, el área pued + ser peligroso y contienen rocas o abismos. O bien, el uso de linternas puede + ser imposible porque sería sospechoso en una zona residencial. + </desc> + <name lang="it">solo di giorno</name> + <desc lang="it"> + Si dovrebbe cercare questa cache solamente durante il giorno. Ad esempio, + l'area può essere pericolosa e contenere scogliere o abissi. Oppure, + l'utilizzo di torce elettriche potrebbe essere impossibile perché + risulterebbe sospetto all'interno di una zona residenziale. + </desc> + </attr> + + <attr okapi_attr_id="night-recommended" categories="de-time-and-seasons"> + <!-- + GS has "night cache" (52) and "recommended at night" (14). + night cache = can normally ONLY be done at night, reflectors etc. + recommended at night = can well be done at night + + On OCPL there is no distinction between these two. OCPL uses + "Recommended at night" attribute for "Night caches" too. + --> + <groundspeak id="14" inc="true" name="Recommended at night" /> + <opencaching site_url="http://opencaching.pl/" id="91" /> + <name lang="en">Recommended at night</name> + <desc lang="pl"> + It is recommended to search for this cache by night. I.e. there + might be some light-reflecting surfaces involved which are usually + invisible during daylight. + </desc> + <name lang="pl">Zalecane szukanie nocą</name> + <desc lang="pl"> + Aby znaleźć skrzynkę zalecane jest poszukiwanie jej nocą, ze + względu na miejsce ukrycia lub użyte elementy odblaskowe, których + oświetlenie umożliwia odnalezienie skrzynki. + </desc> + <name lang="de">am besten nachts findbar</name> + </attr> + + <attr okapi_attr_id="nightcache" categories="de-time-and-seasons"> + <!-- + GS has "night cache" (52) and "recommended at night" (14). + night cache = can normally ONLY be done at night, reflectors etc. + recommended at night = can well be done at night + --> + <groundspeak id="52" inc="true" name="Night Cache" /> + <opencaching site_url="http://opencaching.de/" id="1" /> + <name lang="en">Only at night</name> + <desc lang="en"> + This geocache can be found at night only - it is a so-called night cache. + There may be reflectors which have to be flashlighted and will point + to the hiding place, or other special night-caching mechanisms. + </desc> + <name lang="de">nur bei Nacht</name> + <desc lang="de"> + Der Geocache kann nur bei Nacht gelöst werden und wird deshalb Nachtcache + genannt. Zum Beispiel mössen Reflektoren mit einer Taschenlampe + angeleuchtet werden, die dann den Weg zum Versteck zeigen. + </desc> + <name lang="es">Sólo por la noche</name> + <desc lang="es"> + Esta cache se puede encontrar solamente por la noche - tienes que + considerar cache notturna. Puede haber placas reflectantes que + brillaran y te llevaran al cache, o otros mecanismo especiales para + caches nocturnos. + </desc> + <name lang="it">Solo di notte</name> + <desc lang="it"> + Questa cache può essere trovata solo di notte - è una cosiddetta + cache notturna. Ci possono essere targhette riflettenti che devono + essere illuminate e ti conducono al nascondiglio, o altri speciali + meccanismi di caching notturno. + </desc> + </attr> + + <attr okapi_attr_id="all-seasons" categories="de-time-and-seasons"> + <groundspeak id="62" inc="false" name="Seasonal access" /> + <opencaching site_url="http://opencaching.de/" id="42" /> + <name lang="en">All seasons</name> + <desc lang="en"> + This cache can be found the whole year round, while difficulty may + depend on seasons. + </desc> + <name lang="de">ganzjähig zugänglich</name> + <desc lang="de"> + Dieser Cache lässt sich während des gesamten Jahres finden, wobei je + nach Jahreszeit die Schwierigkeit bei der Suche schwanken kann. + </desc> + <name lang="es">Todas las temporadas</name> + <desc lang="es"> + Esta cache se encuentrar durante todo el año, mientras que la dificultad + puede depender de las estaciones. + </desc> + <name lang="it">Tutte le stagioni</name> + <desc lang="it"> + Questa cache si trova tutto l'anno, mentre la difficoltà può dipendere + dalle stagioni. + </desc> + </attr> + + <attr okapi_attr_id="not-all-seasons" categories="de-time-and-seasons"> + <groundspeak id="62" inc="true" name="Seasonal access" /> + <opencaching site_url="http://opencaching.de/" id="60" /> + <name lang="en">Only available during specified seasons</name> + <desc lang="en"> + This cache can be done at certain seasons only - see the cache + description for more details. + </desc> + <name lang="de">Nur zu bestimmten Zeiten im Jahr</name> + <desc lang="de"> + Dieser Cache lässt sich nur zu bestimmten Zeite im Jahr absolvieren. + Näheres ist in der Cachebeschreibung angegeben. + </desc> + <name lang="es">Sólo disponible durante las estaciones especificadas</name> + <desc lang="es"> + Esta cache se puede hacer en ciertas épocas del año solamente - vea la + descripción de cache para obtener más detalles. + </desc> + <name lang="it">Disponibile solo in certe stagioni</name> + <desc lang="it"> + Questa cache può essere cercata solo in certe stagioni - vedi la + descrizione per ulteriori informazioni. + </desc> + </attr> + + <attr okapi_attr_id="np-season" categories="de-time-and-seasons"> + <opencaching site_url="http://opencaching.de/" id="43" /> + <name lang="en">Breeding season / protected nature</name> + <desc lang="en"> + Don’t seek this cache during animal breeding season! See the cache + description on which time of year must be avoided. Also, pay + attention to the local terms and signs regarding nature protection. + </desc> + <name lang="de">Brutsaison / Naturschutz</name> + <desc lang="de"> + Dieser Cache sollte in der Brutsaison nicht absolviert werden. In der + Beschreibung sollte angegeben sein, welche Jahreszeit davon betroffen ist. + Achte bitte auch auf die örtliche Beschilderung zum Naturschutz. + </desc> + <name lang="es">Temporada de reproducción / protección de la naturaleza</name> + <desc lang="es"> + ¡No intente esta cache durante la temporada de cría de los animales! + Vvéase la descripción del cache de la época del año debe ser evitado. + Preste atención también a las condiciones o signos en cuanto al respeto + por la naturaleza. + </desc> + <name lang="it">Stagione di riproduzione / natura protetta</name> + <desc lang="it"> + Non cercare questa cache durante il periodo riproduttivo degli animali! + Vedi descrizione della cache quale periodo dell'anno debba essere evitato. + Prestate anche attenzione alle condizioni o ai cartelli riguardo il + rispetto della natura. + </desc> + </attr> + + <attr okapi_attr_id="snow-proof" categories="de-time-and-seasons"> + <groundspeak id="15" inc="true" name="Available during winter" /> + <opencaching site_url="http://opencaching.de/" id="44" /> + <name lang="en">Available during winter</name> + <desc lang="en"> + This cache can be found even after heavy snowing. All stages and the + geocache are hidden in a snow-safe way: they will not be covered by + fallen snow, or ice, etc. + </desc> + <name lang="de">schneesicheres Versteck</name> + <desc lang="de"> + Dieser Cache lässt sich auch nach starkem Schneefall suchen. Die einzelnen + Stationen und der Geocache sind so versteckt, dass sie nicht von Schnee + verdeckt werden, bzw. von Schneehaufen die durch Räumfahrzeuge entstehen. + </desc> + <name lang="es">Nieve en el escondite</name> + <desc lang="es"> + Este cache también se puede encontrar después de fuertes nevadas. Todas + las fases y geocaches se esconde en lugares seguros para la caída de la + nieve, no será cubierto por acumulaciones de nieve. + </desc> + <name lang="it">Luogo a prova di neve</name> + <desc lang="it"> + Questa cache può essere trovata anche dopo forti nevicate. Tutte le fasi + e la geocache sono nascosti in luoghi sicuri per la neve: non saranno + coperti da neve caduta né da cumuli di neve creati ad esempio da veicoli + spalaneve. + </desc> + </attr> + + <attr okapi_attr_id="lowwater" categories="de-time-and-seasons"> + <opencaching site_url="http://opencaching.de/" id="41" /> + <name lang="en">Not at high water level</name> + <desc lang="en"> + This cache can be done only at low or normal water level. It is + inaccessible during flood. + </desc> + <name lang="de">nicht bei Hochwasser oder Flut</name> + <desc lang="de"> + Der Geocache kann nur bei bei niedrigem oder normalem Wasserstand + bzw. bei Ebbe gesucht werden. Bei Hochwasser oder Flut ist er + unzugänglich. + </desc> + <!-- TODO: Spanish and Italian translations --> + </attr> + + <attr okapi_attr_id="compass" categories="de-tools"> + <opencaching site_url="http://opencaching.pl/" id="47" /> + <opencaching site_url="http://opencaching.de/" id="47" /> + <name lang="en">Compass required</name> + <desc lang="en"> + A compass is required. + </desc> + <name lang="pl">Potrzebny kompas</name> + <desc lang="pl"> + Kompas może okazać się niezbędny aby dotrzeć do wskazanego miejsca + skrzynki. + </desc> + <name lang="de">Kompass</name> + <desc lang="de"> + Für diesen Cache braucht ihr einen funktionierenden Kompass für Peilungen + oder Orientierungen. + </desc> + <name lang="es">Brújula</name> + <desc lang="es"> + Se necesita una brújula. + </desc> + <name lang="it">Bussola</name> + <desc lang="it"> + E' necessaria una bussola. + </desc> + </attr> + + <attr okapi_attr_id="pen" categories="de-tools"> + <opencaching site_url="http://opencaching.pl/" id="48" /> + <name lang="en">Take something to write</name> + <desc lang="en"> + There is no pencil in the cache. Take something to write with. + </desc> + <name lang="pl">Weź coś do pisania</name> + <desc lang="pl"> + Skrzynka nie zawiera ołówka, weź ze sobą coś do pisania. + </desc> + <desc lang="de">Stift mitbringen</desc> + </attr> + + <attr okapi_attr_id="digging" categories="de-tools"> + <opencaching site_url="http://opencaching.pl/" id="81" /> + <name lang="en">You may need a shovel</name> + <desc lang="en"> + The cache may require more digging. A shovel might come in handy. + </desc> + <name lang="pl">Potrzebna łopatka</name> + <desc lang="pl"> + Skrzynka jest zakopana w ziemi. + </desc> + <desc lang="de">Grabwerkzeug benötigt</desc> + </attr> + + <attr okapi_attr_id="flashlight" categories="de-tools"> + <groundspeak id="44" inc="true" name="Flashlight required" /> + <opencaching site_url="http://opencaching.pl/" id="82" /> + <opencaching site_url="http://opencaching.de/" id="48" /> + <name lang="en">Flashlight required</name> + <desc lang="en"> + You will need a flashlight to find this cache. + </desc> + <name lang="pl">Potrzebna latarka</name> + <desc lang="pl"> + Przy poszukiwaniach tej skrzynki potrzebna jest latarka. + </desc> + <name lang="de">Taschenlampe</name> + <desc lang="de"> + Um diesen Cache anzugehen, benötigt ihr eine funktionstüchtige + Taschenlampe. Denkt auch an Ersatzbatterien. + </desc> + <name lang="es">Linterna</name> + <desc lang="es"> + Es necesario una linterna para encontrar este cache. ¡No se olvide de las + baterías de repuesto! + </desc> + <name lang="it">Lampada tascabile</name> + <desc lang="it"> + E' necessaria una torcia portatile per trovare questa cache. Non + dimenticate le batterie di riserva! + </desc> + </attr> + + <attr okapi_attr_id="climbing-gear" categories="de-tools"> + <groundspeak id="3" inc="true" name="Climbing gear" /> + <opencaching site_url="http://opencaching.de/" id="49" /> + <name lang="en">Climbing gear required</name> + <desc lang="en"> + For this cache, you will need climbing equipment and the knowledge + how to use it properly. If you are a beginner, don’t do it alone but + use the support of an experienced climber or mountaineer. + </desc> + <name lang="de">Kletterzeug</name> + <desc lang="de"> + Um diesen Cache absolvieren zu können, benötigt ihr neben der normalen + Ausrüstung auch noch Kletterausrüstung, und entsprechendes Wissen um + deren Handhabung und ums Klettern. Laien sollten sich auf jeden Fall + von einem erfahrenen Kletterer oder Bergsteiger unterstützen lassen. + </desc> + <name lang="es">Equipo de escalada</name> + <desc lang="es"> + Para este cache, tendrá que utilizar los equipos y saber cómo utilizarlo + correctamente. Si usted es un principiante, no lo haga solos, sino que + utiliza el apoyo de un experimentado escalador o alpinista. + </desc> + <name lang="it">Attrezzatura per arrampicata</name> + <desc lang="it"> + Per questa cache, avrete bisogno di materiale da arrampicata e di saperlo + usare correttamente. Se sei un principiante, non farlo da solo, ma + utilizza il sostegno di uno scalatore esperto o un alpinista. + </desc> + </attr> + + <attr okapi_attr_id="cave-equipment" categories="de-tools"> + <opencaching site_url="http://opencaching.de/" id="50" /> + <name lang="en">Cave equipment required</name> + <desc lang="en"> + This geocache is hidden in a cave, and you should use appropriate + equipment to access it. Beware: Even small caves may confront you with + unforeseen problems and dangers, like thunder storms (water!) or a + sprained ankle. Have advice first from cave-experienced people! Also + take care of protected nature; e.g. bat places must not be disturbed. + </desc> + <name lang="de">Höhlenzeug</name> + <desc lang="de"> + Der Geocache ist in einer Höhle versteckt und man sollte entsprechende + Ausrüstung mitbringen. Vorsicht: Bereits kleinste Höhlensysteme können + bei unvorhergesehenen Problem z.B. Gewittern (Wasser!) oder einem + verstauchten Knöchel sehr gefährlich werden! Ihr solltet euch vorab + gründlich bei erfahreren Höhlengehern informieren. Beachtet auch den + Naturschutz – Fledermausquartiere dürfen nicht gestört werden! + </desc> + <name lang="es">Equipación para cuevas</name> + <desc lang="es"> + Este geocache está escondido en una cueva, y se debe utilizar el equipo + adecuado para acceder a ella. Tenga en cuenta que incluso las pequeñas + cuevas pueden prever los problemas imprevistos y peligros, como durante + las tormentas o con un esguince de tobillo. ¡Acceda con personas + experimentadas en cuevas! También debe protegerse la naturaleza sobre + todo en esos lugares donde los murciélagos no deben ser molestados. + </desc> + <name lang="it">Attrezzatura per grotta</name> + <desc lang="it"> + Questa geocache è nascosta in una grotta, e si dovrebbe utilizzare + attrezzature adeguate per accedervi. Attenzione: anche piccole grotte + possono prevedere problemi imprevisti e pericoli, come in caso di + temporali (acqua!) o una caviglia slogata. Consigliatevi prima con + persone che abbiano esperienza di grotte! Abbiate anche cura della + natura protetta, ad esempio dei luoghi dove i pipistrelli non devono + essere disturbati. + </desc> + </attr> + + <attr okapi_attr_id="diving-equipment" categories="de-tools"> + <groundspeak id="5" inc="true" name="Scuba gear" /> + <opencaching site_url="http://opencaching.de/" id="51" /> + <name lang="en">Diving equipment required</name> + <desc lang="en"> + You will need diving equipment to find this geocache. The water depth + of the cache location is specified in the description. Please note that + secure diving requires special training. Without diving experience, + you may search this cache in company of a diving teacher. + </desc> + <name lang="de">Taucherausrüstung</name> + <desc lang="de"> + Um den Geocache zu finden benötigt ihr eine Tauchausrüstung. In welcher + Tiefe der Geocache liegt ist in der Beschreibung angegeben. Bitte beachtet, + dass Ihr für einen sicheren Tauchgang eine entsprechende Ausbildung + benötigt. Als Nicht-Taucher könnt ihr den Geocache evtl. zusammen mit + einem Tauchlehrer suchen. + </desc> + <name lang="es">Diving equipment</name> + <desc lang="es"> + Necesitará un equipo de buceo para encontrar este geocache. La + profundidad del agua en la ubicación de la cache se especifica en la + descripción. Tenga en cuenta que el buceo requiere un entrenamiento + especial. Sin experiencia de buceo, puedes buscar por el caché, junto + con un buceador experimentado. + </desc> + <name lang="it">Equipo de buceo</name> + <desc lang="it"> + Avrete bisogno di attrezzatura subacquea per trovare questa geocache. + La profondità d'acqua nella posizione della cache viene specificata nella + descrizione. Si prega di notare che l'immersione in tutta sicurezza + richiede una formazione specifica. Senza esperienza di immersioni, è + possibile cercare questa cache in compagnia di un insegnante di sub. + </desc> + </attr> + + <attr okapi_attr_id="special-tools" categories="de-tools"> + <groundspeak id="51" inc="true" name="Special tool required" /> + <opencaching site_url="http://opencaching.pl/" id="83" /> + <opencaching site_url="http://opencaching.de/" id="46" /> + <name lang="en">Special tools required</name> + <desc lang="en"> + You will need special equipment which is not specified by other attributes. + See the cache description on what tools are required. + </desc> + <name lang="pl">Wymagany dodatkowy sprzęt</name> + <desc lang="pl"> + Niezbędny jest dodatkowy, niestandardowy sprzęt - może to być np. + kajak, sprzęt wspinaczkowy, ale również kalkulator, kalosze itp. + Ogólnie przedmioty, które nie należą do standardowego wyposażenia + poszukiwacza. + </desc> + <name lang="de">spezielle Ausrüstung</name> + <desc lang="de"> + Für diesen Cache benötigst du weitere Ausrüstung, die nicht durch die + anderen Attribute angegeben ist und nicht zur Standardausrüstung eines + Geocachers gehört. Was genau du benütigst, ist in der Beschreibung + angegeben. + </desc> + <name lang="es">Equipamiento especial</name> + <desc lang="es"> + Necesitarás un equipo especial no especificado por otros atributos. + </desc> + <name lang="it">Equipaggiamento speciale</name> + <desc lang="it"> + Avrete bisogno di attrezzature speciali non specificate da altri attributi. + </desc> + </attr> + + <attr okapi_attr_id="boat" categories="de-tools"> + <groundspeak id="4" inc="true" name="Boat" /> + <opencaching site_url="http://opencaching.pl/" id="86" /> + <opencaching site_url="http://opencaching.de/" id="52" /> + <name lang="en">Requires a boat</name> + <desc lang="en"> + This cache can usually be found only when using a watercraft. + Swimming is difficult or impossible because of the distance or currents. + See the cache description for more details. + </desc> + <name lang="pl">Wymaga sprzętu pływającego</name> + <desc lang="pl"> + Skrzynka z tym atrybutem najczęściej może być zdobyta jedynie przy + użyciu sprzętu pływającego (łodzi, pontonu, kajaka itp.) Dopłynięcie + wpław jest trudne lub niemożliwe, ze względu na dystans, silne + prądy itp. + </desc> + <name lang="de">Wasserfahrzeug</name> + <desc lang="de"> + Der Geocache kann – normalerweise – nicht ohne ein Wasserfahrzeug gefunden + werden. Zum Geocache kann wegen der Entfernung oder Strömung nicht + geschwommen werden. Details dazu sind in der Beschreibung des Geocaches + angegeben. + </desc> + <name lang="es">Barca</name> + <desc lang="es"> + Este cache por lo general sólo se puede encontrar con una moto de agua. + Nadando es imposible debido a la distancia o la corriente. Véase la + descripción del cache para obtener más detalles. + </desc> + <name lang="it">Barca</name> + <desc lang="it"> + Questa cache di solito può essere trovata solo con una moto d'acqua. Il + nuoto è impossibile a causa della distanza o delle correnti. Vedi la + descrizione della cache per maggiori dettagli. + </desc> + </attr> + + <attr okapi_attr_id="nogps" categories="de-tools"> + <opencaching site_url="http://opencaching.de/" id="35" /> + <name lang="en">No GPS required</name> + <desc lang="en"> + This cache can be found without a GPS device. No additional coordinates + are used besides of the starting coordinates. + </desc> + <name lang="de">ohne GPS findbar</name> + <desc lang="de"> + Dieser Cache lässt sich auch ohne GPS-Empfänger finden. Die Aufgaben + sind so gestellt, dass man außer den Startkoordinaten keine weiteren + Koordinaten verwenden muss. + </desc> + <name lang="es">Sin GPS</name> + <desc lang="es"> + Esta cache se puede encuentra sin un dispositivo GPS. Detalles adicionales + no se utilizan, además de las coordenadas iniciales. + </desc> + <name lang="it">Senza GPS</name> + <desc lang="it"> + Questa cache può essere trovata senza un dispositivo GPS. Non sono + utilizzate coordinate addizionali oltre alle coordinate iniziali. + </desc> + </attr> + + <attr okapi_attr_id="dangerous-area" categories="de-dangers"> + <groundspeak id="23" inc="true" name="Dangerous area" /> + <opencaching site_url="http://opencaching.de/" id="9" /> + <opencaching site_url="http://opencaching.pl/" id="90" /> + <name lang="en">Dangerous area</name> + <desc lang="en"> + The cache is located within a dangerous area, and danges may not be + obvious, e.g. like high-traffic roads, steep ground or falling rocks. + Safety measures should be taken, especially when geocaching with + children, large groups of people or during bad weather conditions. + </desc> + <name lang="pl">Skrzynka niebezpieczna</name> + <desc lang="pl"> + Skrzynka jest ukryta w niebezpiecznym terenie. Jej poszukiwania mogą + narazić na niebezpieczeństwo wypadku lub urazu. + </desc> + <name lang="de">gefährliches Gebiet</name> + <desc lang="de"> + In dem Gebiet, wo der Geocache versteckt wurde, ist mit Gefahren zu + rechnen, die unter Umständen nicht auf den ersten Blick erkennbar sind. + Das können z.B. stark befahrene Straßen, steile Abhänge oder Steinschlag + sein. Deshalb sollte man bei Geocaching-Touren mit Kindern oder größeren + Gruppen entsprechende Vorsichtsmaßnahmen ergreifen und je nachdem auch + auf die Witterung achten (z.B. Regen bei steilen Abhängen). + Näheres zu den Gefahren ist in der Cachebeschreibung erläutert. + </desc> + <name lang="es">Zona Peligrosa</name> + <desc lang="es"> + El cache está situado en una zona peligrosa, como tales como carreteras + con mucho tráfico, terreno empinado o caída de rocas. Usted debe tomar + medidas de seguridad o evitar ir a buscar el caché, sobre todo con niños, + con grupos grandes o en condiciones meteorológicas adversas. + </desc> + <name lang="it">Area pericolosa</name> + <desc lang="it"> + La cache è situata in un'area pericolosa come strade ad alto traffico, + terreno ripido o caduta sassi. Si dovrebbero adottare misure di sicurezza + o evitare di andare a cercare la cache, in particolare nel geocaching con + bambini, con gruppi numerosi o in condizioni climatiche sfavorevoli. + </desc> + </attr> + + <attr okapi_attr_id="railway" categories="de-dangers"> + <opencaching site_url="http://opencaching.de/" id="10" /> + <name lang="en">Active railway nearby</name> + <desc lang="en"> + There are active railroads nearby. Please be careful, keep a safe + distance and cross the rails only at level crossings etc.! + </desc> + <name lang="de">aktive Eisenbahnlinie in der Nähe</name> + <desc lang="de"> + In der Nähe dieses Caches gibt es genutzte Eisenbahnlinien. Bitte seid + entsprechend vorsichtig und achtet darauf, abseits von Bahnübergängen keine + Gleise zu betreten. + </desc> + <name lang="es">Cerca del ferrocarril activo</name> + <desc lang="es"> + ¡Hay ferrocarriles activos en las proximidades. Por favor, tenga + cuidado, manteniendo una distancia segura y cruzar los rieles sólo + en los cruces de ferrocarril, etc.! + </desc> + <name lang="it">Ferrovia attiva nei pressi</name> + <desc lang="it"> + Ci sono ferrovie attive nelle vicinanze. Per favore usate cautela, + tenendo una distanza di sicurezza e attraversando le rotaie solo ai + passaggi a livello ecc.! + </desc> + </attr> + + <attr okapi_attr_id="cliff" categories="de-dangers"> + <groundspeak id="21" inc="true" name="Cliff / falling rocks" /> + <opencaching site_url="http://opencaching.de/" id="11" /> + <name lang="en">Cliff / Rocks</name> + <desc lang="en"> + There are cliffs or dangerous rocks nearby. Beware of falling rocks + at the lower side, and be careful at the upper side of cliffs - + especially with children and while mountain biking. It can be very + dangerous to take a steep slope towards a cliff, because you may not + notice in time where the former ends and the latter starts. + </desc> + <name lang="de">Klippen / Felsen</name> + <desc lang="de"> + In der Nähe des Caches gibt es Klippen oder Felsen. Unterhalb von + Felsen sollte man auf Steinschlag achten, von der Oberseite der Klippen + sollte man sich entsprechend vorsichtig nähern (insbesondere mit Kindern + oder Mountainbikes). Besonders gefährlich - und nicht immer erkennbar - + ist es, sich über einen Steilhang von oben an eine Klippe zu nähern. + </desc> + <name lang="es">Acantilado / Rocas</name> + <desc lang="es"> + Hay acantilados o rocas peligrososas en las cercanas. Tenga cuidado + cuando esté bajo las piedras caídas, y tenga cuidado cuando esté sobre + el acantilado - especialmente con los niños y el ciclismo. Puede ser + muy peligroso tomar un camino empinado para subir el acantilado porque + no se puede saber de antemano cuando el primero termina y comienza otra. + </desc> + <name lang="it">Scogliera / Rocce</name> + <desc lang="it"> + Ci sono scogliere o rocce pericolose nelle vicinanze. Fate attenzione + alla caduta pietre quando siete sotto, e siate cauti quando siete sopra + la scogliera - specialmente con bambini e in bicicletta. Può essere molto + pericoloso prendere un sentiero ripido per salire la scogliera, poiché + non potete sapere in anticipo quando la prima termina e inizia l'altra. + </desc> + </attr> + + <attr okapi_attr_id="hunting" categories="de-dangers"> + <groundspeak id="22" inc="true" name="Hunting" /> + <opencaching site_url="http://opencaching.de/" id="12" /> + <name lang="en">Hunting</name> + <desc lang="en"> + The geocache is placed within a hunting ground. At twilight and in the + dark, a flashlight or headlight should always be used for security + reasons. Be considerate when meeting hunters. + </desc> + <name lang="de">Jagdgebiet</name> + <desc lang="de"> + Der Geocache liegt in einem Jagdgebiet. Bei Dämmerung oder Dunkelheit + sollte man aus Sicherheitsgründen immer eine Taschenlampe oder + Stirnlampe verwenden. Bei Begegnungen mit Jägern ist gegenseitige + Rücksichtnahme angebracht. + </desc> + <name lang="es">Zona de Caza</name> + <desc lang="es"> + El geocache se coloca dentro de un coto de caza. Al caer la tarde y en + la oscuridad, una linterna o faro siempre debe utilizarse por razones + de seguridad. + </desc> + <name lang="it">Caccia</name> + <desc lang="it"> + La geocache è situata nei pressi di una area di caccia. Al crepuscolo + e al buio, dovrebbe sempre essere usata una torcia portatile o frontale + per ragioni di sicurezza. Incontrando i cacciatori è opportuna una + reciproca gentilezza. + </desc> + </attr> + + <attr okapi_attr_id="thorns" categories="de-dangers"> + <groundspeak id="39" inc="true" name="Thorns" /> + <opencaching site_url="http://opencaching.de/" id="13" /> + <name lang="en">Thorns</name> + <desc lang="en"> + There are thorns near the cache. Wear appropriate clothes. + </desc> + <name lang="de">Dornen</name> + <desc lang="de"> + In er Nähe des Geocaches gibt es Dornen. Entsprechende Kleidung und + evtl. Handschuhe sind zu empfehlen. + </desc> + <name lang="es">Espinas</name> + <desc lang="es"> + Hay espinas cerca de la caché. Use ropa apropiada. + </desc> + <name lang="it">Spine</name> + <desc lang="it"> + Ci sono spine nei pressi della cache. Indossare indumenti appropriati. + </desc> + </attr> + + <attr okapi_attr_id="ticks" categories="de-dangers"> + <groundspeak id="19" inc="true" name="Ticks" /> + <opencaching site_url="http://opencaching.de/" id="14" /> + <name lang="en">Ticks</name> + <desc lang="en"> + There are seasonably many ticks in this area. It is recommended to wear + long trousers and to check yourself for ticks after geocaching. + There are regional risk maps for <i>tick-borne encephalitis</i> on the + internet. + </desc> + <name lang="de">Zecken</name> + <desc lang="de"> + Je nach Saison gibt es in dem Gebiet besonders viele Zecken. Es wird + daher empfohlen, entsprechend lange Kleidung zu tragen und nach der + Cachetour nach Zecken Ausschau zu halten. FSME-Risikogebiete und + weitere Informationen zum Thema Zecken könnt ihr z.B. auf + <a href='http://www.meningitis.de'>www.meningitis.de</a> nachsehen. + </desc> + <name lang="es">Garrapatas</name> + <desc lang="es"> + Cada temporada hay un montón de garrapatas en este lubar. Y es + recomendable llevar pantalón largo y examinarse en busca de garrapatas + después de encontrar el cache. + </desc> + <name lang="it">Zecche</name> + <desc lang="it"> + Stagionalmente ci sono molte zecche in questa area. E' raccomandabile + indossare pantaloni lunghi e ispezionarsi alla ricerca di zecche dopo + il geocaching. In internet ci sono mappe di rischio per <i>encefalite + e borelliosi da morso di zecca</i>. + </desc> + </attr> + + <attr okapi_attr_id="mines" categories="de-dangers"> + <groundspeak id="20" inc="true" name="Abandoned mines" /> + <opencaching site_url="http://opencaching.de/" id="15" /> + <name lang="en">Abandoned mines</name> + <desc lang="en"> + This cache leads into a (former) mining area. There may be dangers by + collapsing adits, or you may need to enter adits. Be careful and use + appropriate equipment, especially in the dark. Old mines may be covered + by historic preservation. + </desc> + <name lang="de">Folgen des Bergbaus</name> + <desc lang="de"> + Der Cache führt in eine (ehemalige) Bergbauregion. Möglicherweise + bestehen Gefahren durch verstürzte Stollenmundlöcher oder es müssen + Stollen betreten werden. Entsprechende Ausrüstung und Vorsicht, + besonders bei Dunkelheit, wird empfohlen. Historische Bergwerke stehen + möglicherweise unter Denkmalschutz. + </desc> + <name lang="es">Mina abandonada</name> + <desc lang="es"> + Esta cache le llevará a un área de la mina (abandonado). Puede haber + peligro con el colapso de túneles o galerías que puede ser necesario para + cruzar. Tenga cuidado y use de equipo adecuado, especialmente en la + oscuridad. Las minas antiguas pueden ser objeto de preservación histórica. + </desc> + <name lang="it">Miniere abbandonate</name> + <desc lang="it"> + Questa cache vi porta in una area di miniera (abbandonata). Ci possono + essere pericoli per crollo di gallerie, o potrebbe essere necessario + attraversare gallerie. Fare attenzione e utilizzate attrezzature adeguate, + soprattutto al buio. Le vecchie miniere possono essere oggetto di + conservazione storica. + </desc> + </attr> + + <attr okapi_attr_id="poisonous-plants" categories="de-dangers"> + <groundspeak id="17" inc="true" name="Poisonous plants" /> + <opencaching site_url="http://opencaching.de/" id="16" /> + <name lang="en">Poisonous plants</name> + <desc lang="en"> + There are poisonous plants near the cache. Take care and prevent + children and dogs from touching or eating them. + </desc> + <name lang="de">giftige Pflanzen</name> + <desc lang="de"> + In der Nähe des Caches gibt es giftige Pflanzen. Achtet also insbesondere + darauf, dass Kinder und Hunde diese nicht anfassen oder essen. + </desc> + <name lang="es">Planta venenosa</name> + <desc lang="es"> + Hay plantas venenosas en las cercanías. Tenga cuidado y asegúrese de que + los niños o los perros no las toquen ni tragarlas. + </desc> + <name lang="it">Piante velenose</name> + <desc lang="it"> + Ci sono piante velenose nelle vicinanze. Fate attenzione e controllate + che bambini o cani non le tocchino o le ingoino. + </desc> + </attr> + + <attr okapi_attr_id="dangerous-animals" categories="de-dangers"> + <groundspeak id="18" inc="true" name="Dangerous animals" /> + <opencaching site_url="http://opencaching.de/" id="17" /> + <name lang="en">Dangerous animals</name> + <desc lang="en"> + The area is inhabited by possibly dangerous animals, e.g. rabies areas, + venomous snakes, scorpions or bears. + </desc> + <name lang="de">giftige/gefährliche Tiere</name> + <desc lang="de"> + In dem Gebiet sind Wildtiere angesiedelt, die für Menschen eine Gefahr + darstellen können, z.B. Tollwutgebiete, giftige Schlangen, Skorpione + oder Bären. + </desc> + <name lang="es">Animales Peligrosos</name> + <desc lang="es"> + Esta zona es frecuentada por los animales potencialmente peligrosos, + por ejemplo. zorros rabiosos, serpientes venenosas, escorpiones, osos. + </desc> + <name lang="it">Animali pericolosi</name> + <desc lang="it"> + Quest area è frequentata da animali potenzialmente pericolosi, ad es. + volpi rabide, serpenti velenosi, scorpioni, orsi. + </desc> + </attr> + + <attr okapi_attr_id="quick" categories="de-rating"> + <!-- TODO: There is a groundspeak attribute called "Takes less than + 1 hour", is it applicable here? I'm not sure... In OCPL this attribute + was called "One-minute cache", and the official description includes + a 15 minutes limit. --> + <opencaching site_url="http://opencaching.pl/" id="40" /> + <name lang="en">Quick cache</name> + <desc lang="en"> + It shouldn't take more than 15 minutes to find this cache. Also, + there should be a parking nearby. + </desc> + <name lang="pl">Szybka skrzynka</name> + <desc lang="pl"> + Jej znalezienie nie powinno zająć więcej niż 15 minut oraz jest + łatwy dojazd w pobliże skrzynki samochodem. + </desc> + <desc lang="de">schnell findbar</desc> + </attr> + + <attr okapi_attr_id="overnight" categories="de-rating"> + <opencaching site_url="http://opencaching.de/" id="37" /> + <name lang="en">Overnight stay necessary</name> + <desc lang="en"> + This cache cannot be done within a single day or a single night. + You will have to visit the location for more than one time, + or you must stay overnight. Preparation time is not included in this + calculation, but only the time on site. + </desc> + <name lang="de">Übernachtung erforderlich</name> + <desc lang="de"> + Der Geocache kann nicht mit einer einzigen Tages- oder Nachttour gelöst + werden. Er muss entweder mehrmals angefahren werden oder es muss vor Ort + übernachtet werden. Zeit für Recherchen vorab sind dabei nicht + berücksicht, sondern nur die Zeit vor Ort. + </desc> + <name lang="es">Necesario pernoctar</name> + <desc lang="es"> + No puedrá encontrar este cache en un solo día o durante la noche. Usted + tendrá que visitar el lugar más de una vez, o necesitará pasar la noche. + El tiempo de preparación no está incluido en este cálculo, sólo el tiempo + en el sitio. + </desc> + <name lang="it">Necessario pernottamento</name> + <desc lang="it"> + Non è possibile trovare questa cache in un solo giorno o una sola notte. + Dovrete visitare il percorso per più di una volta, oppure è necessario il + pernottamento. Il tempo di preparazione non è incluso in questo calcolo, + ma solo il tempo sul sito. + </desc> + </attr> + + <attr okapi_attr_id="children6" categories="de-rating"> + <groundspeak id="6" inc="true" name="Recommended for kids" /> <!-- Not sure if this is correct. --> + <opencaching site_url="http://opencaching.pl/" id="41" /> + <name lang="en">Take your children</name> + <desc lang="pl"> + This search if simple and safe. It's okay to take small children + with you. + </desc> + <name lang="pl">Można zabrać dzieci</name> + <desc lang="pl"> + Jej poszukiwanie jest przyjemne, bezpieczne i można bez obaw + wybrać się z małymi dziećmi. + </desc> + </attr> + + <attr okapi_attr_id="children10" categories="de-rating"> + <groundspeak id="6" inc="true" name="Recommended for kids" /> + <opencaching site_url="http://opencaching.de/" id="59" /> + <name lang="en">Suited for children (10-12 yo)</name> + <desc lang="en"> + This geocache is suitable for children. All challenges can be solved by + child in the age of 10 to 12 years and the terrain has no risks + (like highways, abysms). There should be a large geocache container with + trading items inside and the challenges be interesting. + </desc> + <name lang="de">kindgerecht (10-12 Jahre)</name> + <desc lang="de"> + Der Geocache ist kindgerecht aufgebaut: Alle Aufgaben sind von Kindern + im Alter von 10 bis 12 Jahren selbstständig lösbar und das Gelände ist + nicht gefährlich (keine Haupstraßen, Klippen o.ä.). Am Ende des + Geocaches sollte sich eine Box mit Tauschgegenständen befinden, und + die Aufgaben sollten interessant aufgebaut sein. + </desc> + <name lang="es">Apto para niños (10-12 años)</name> + <desc lang="es"> + Este geocache se creó para los niños. Todas las tareas se puede + completar por los niños entre los años 10 y 12 y el terrno no está + exenta de riesgo (tales como carreteras, acantilados). Hay un gra + contenedor con intercambio final y las tareas son interesantes. + </desc> + <name lang="it">Suited for children (10-12 anni)</name> + <desc lang="it"> + Questa geocache è stata creata per i bambini. Tutte i compiti possono + essere portati a termine da bambini tra 10 e 12 anni e il terreno non + presenta rischi (come autostrade, abissi). C'e un grande contenitore + finale con oggetti di scambio e i compiti sono interessanti. + </desc> + </attr> + +</xml> diff --git a/main/project/attributes_okapi/genattr.jar b/main/project/attributes_okapi/genattr.jar Binary files differnew file mode 100644 index 0000000..7ee5bc4 --- /dev/null +++ b/main/project/attributes_okapi/genattr.jar diff --git a/main/project/attributes_okapi/genattr.sh b/main/project/attributes_okapi/genattr.sh new file mode 100644 index 0000000..7cc23be --- /dev/null +++ b/main/project/attributes_okapi/genattr.sh @@ -0,0 +1,2 @@ +#!/bin/bash +java -jar genattr.jar attributes.xml > AttributeParser.java diff --git a/main/project/attributes_okapi/readme.txt b/main/project/attributes_okapi/readme.txt new file mode 100644 index 0000000..5382ebe --- /dev/null +++ b/main/project/attributes_okapi/readme.txt @@ -0,0 +1,10 @@ +In the current version of OKAPI (rev. 798) are attributes not returned with a unified id but only with the localized text. +Luckily a metadata file to prepare the unification of these attributes has already been prepared by the OKAPI project +(http://code.google.com/p/opencaching-api/source/browse/trunk/etc/attributes.xml), which do not officially publish as a stable definition, +but which can serve as an easier starting point for the generation of a parser class. +To allow the representation with icons we need to map these localized texts to our internal ids which is done with a parser +generated from the aforementioned file. Soo the AttrGen project for more details. + +If attributes.xml will be updated, we need of course to check first if it is structurally compatible to the previous version. +If present it seems to be necessary to remove the BOM at the beginning of the file. Then you can run genattr.sh +and copy the generated AttributeParser.java to the appropriate location (connector.oc). diff --git a/main/res/layout/twitter_authorization_activity.xml b/main/res/layout/authorization_activity.xml index ec9aa8a..931441d 100644 --- a/main/res/layout/twitter_authorization_activity.xml +++ b/main/res/layout/authorization_activity.xml @@ -19,6 +19,7 @@ android:orientation="vertical" > <TextView + android:id="@+id/auth_1" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_gravity="left|center_vertical" @@ -28,11 +29,11 @@ android:drawableLeft="@drawable/cgeo" android:drawablePadding="15dip" android:gravity="left|center_vertical" - android:text="@string/about_auth_1" android:textColor="?text_color" android:textSize="14sp" /> <TextView + android:id="@+id/auth_2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="left|center_vertical" @@ -40,7 +41,6 @@ android:layout_marginLeft="10dip" android:layout_marginRight="10dip" android:gravity="left|center_vertical" - android:text="@string/about_auth_2" android:textColor="?text_color" android:textSize="14sp" /> @@ -52,20 +52,17 @@ <Button android:id="@+id/start" - style="@style/button_full" - android:text="@string/auth_authorize" /> + style="@style/button_full" /> <EditText android:id="@+id/pin" style="@style/edittext_full" - android:hint="@string/auth_pin_hint" android:inputType="number" android:visibility="gone" /> <Button android:id="@+id/pin_button" style="@style/button_full" - android:text="@string/auth_finish" android:visibility="visible" /> </LinearLayout> </LinearLayout> diff --git a/main/res/layout/init.xml b/main/res/layout/init.xml index 2ee8a6b..e784b21 100644 --- a/main/res/layout/init.xml +++ b/main/res/layout/init.xml @@ -28,7 +28,32 @@ style="@style/separator_horizontal_headline" android:text="@string/init_geocaching" /> </RelativeLayout> - + + <LinearLayout + android:layout_width="fill_parent" + android:layout_height="wrap_content" + android:layout_margin="3dip" + android:orientation="horizontal" + android:padding="3dip" > + + <CheckBox android:id="@+id/gc_option" + android:layout_width="wrap_content" + android:layout_height="wrap_content" + android:layout_gravity="left" + android:padding="1dip" + android:gravity="center" /> + + <TextView + android:layout_width="fill_parent" + android:layout_height="wrap_content" + android:layout_gravity="center_vertical" + android:gravity="left" + android:paddingRight="3dip" + android:textSize="14sp" + android:textColor="?text_color" + android:text="@string/init_gc_activate" /> + </LinearLayout> + <TextView android:id="@+id/legal_note" android:layout_width="wrap_content" @@ -85,14 +110,14 @@ android:layout_marginLeft="10dip" android:layout_marginRight="10dip" android:padding="3dip" - android:text="@string/init_oc_username_description" + android:text="@string/init_oc_de_description" android:textColor="?text_color" android:textSize="14sp" /> - <EditText - android:id="@+id/oc_username" - style="@style/edittext_full" - android:hint="@string/init_oc_username" /> + <Button + android:id="@+id/register_oc_de" + style="@style/button_full" + android:text="@string/init_register_oc_de" /> <!-- ** --> <RelativeLayout style="@style/separator_horizontal_layout" > @@ -824,4 +849,4 @@ </LinearLayout> </ScrollView> -</LinearLayout>
\ No newline at end of file +</LinearLayout> diff --git a/main/res/values-cs/strings.xml b/main/res/values-cs/strings.xml index db5ad9d..f29f7e6 100644 --- a/main/res/values-cs/strings.xml +++ b/main/res/values-cs/strings.xml @@ -364,8 +364,6 @@ <string name="init_gc_activate">Aktivace Geocaching.com na Aktivní mapě a ve vyhledávání</string> <string name="init_oc">opencaching.de</string> <string name="init_oc_activate">Aktivace opencaching.de na Aktivní mapě a ve vyhledávání</string> - <string name="init_oc_username_description">Zadej své uživatelské jméno pro opencaching.de kvůli možnosti označovat nálezy.</string> - <string name="init_oc_username">Zadej své uživatelské jméno</string> <string name="init_gcvote">GCvote.com</string> <string name="init_twitter">Twitter</string> <string name="init_username">Uživatelské jméno</string> diff --git a/main/res/values-de/strings.xml b/main/res/values-de/strings.xml index 266e6ce..69838db 100644 --- a/main/res/values-de/strings.xml +++ b/main/res/values-de/strings.xml @@ -372,8 +372,8 @@ <string name="init_gc_activate">Geocaching.com auf Live-Karte und für die Suche aktivieren</string> <string name="init_oc">opencaching.de</string> <string name="init_oc_activate">Opencaching.de auf Live-Karte und für die Suche aktivieren</string> - <string name="init_oc_username_description">Benutzername für opencaching.de eingeben damit gefundene Caches markiert werden können.</string> - <string name="init_oc_username">Benutzername</string> + <string name="init_oc_de_description">Autorisiere c:geo dazu auf opencaching.de zuzugreifen um Caches zu suchen und nach deinen Funden zu filtern.</string> + <string name="init_register_oc_de">c:geo autorisieren</string> <string name="init_gcvote">GCvote.com</string> <string name="init_twitter">Twitter</string> <string name="init_username">Benutzername</string> @@ -486,7 +486,7 @@ <string name="sendToCgeo_download_fail">c:geo konnte Caches nicht laden. Entweder besteht keine Internetverbindung oder send2c:geo funktioniert nicht.</string> <string name="sendToCgeo_no_registration">c:geo konnte Caches nicht laden. Registrierung für send2c:geo ungültig. Bitte in Einstellungen neu registrieren.</string> - <!-- auth --> + <!-- auth twitter --> <string name="auth_twitter">Twitter</string> <string name="auth_authorize">c:geo autorisieren</string> <string name="auth_start">Starte Autorisierung</string> @@ -497,6 +497,22 @@ <string name="auth_dialog_pin_title">PIN Code</string> <string name="auth_dialog_pin_message">Bitte den Twitter-PIN-Code eingeben, dies ist notwendig um die Autorisierung abzuschließen.</string> <string name="auth_dialog_completed">c:geo ist nun autorisiert, Tweets bei Twitter zu erstellen.</string> + <string name="about_auth_1">Der folgende Prozess erlaubt es <b>c:geo</b> auf den persönlichen Twitter-Account zuzugreifen, wenn zugestimmt wird.</string> + <string name="about_auth_2">Ein Klick auf \"Starte Autorisierung\" öffnet eine Twitter-Seite in einem Browserfenster. Durch die Anmeldung und die Bestätigung wird <b>c:geo</b> ermöglicht, auf den persönlichen Twitter-Account zuzugreifen. Wird dies bestätigt, nennt Twitter eine numerische PIN, diese muss kopiert und in <b>c:geo</b> eingefügt werden. Das ist alles.</string> + + <!-- auth opencaching --> + <string name="auth_ocde">opencaching.de</string> + <string name="auth_authorize_oc">c:geo autorisieren</string> + <string name="auth_start_oc">Starte Autorisierung</string> + <string name="auth_again_oc">Neustarten</string> + <string name="auth_pin_hint_oc">%s-PIN</string> + <string name="auth_finish_oc">Fertig</string> + <string name="auth_dialog_wait_oc">Warten auf %s…</string> + <string name="auth_dialog_pin_title_oc">PIN Code</string> + <string name="auth_dialog_pin_message_oc">Bitte den %s-PIN-Code eingeben, dies ist notwendig um die Autorisierung abzuschließen.</string> + <string name="auth_dialog_completed_oc">c:geo ist nun autorisiert, caches zu laden und auf %s zu loggen.</string> + <string name="about_auth_1_oc">Der folgende Prozess erlaubt es <b>c:geo</b> auf den persönlichen %s-Account zuzugreifen, wenn zugestimmt wird.</string> + <string name="about_auth_2_oc">Ein Klick auf \"Starte Autorisierung\" öffnet eine %s-Seite in einem Browserfenster. Durch die Anmeldung und die Bestätigung wird <b>c:geo</b> ermöglicht, auf den persönlichen Account zuzugreifen. Wird dies bestätigt, nennt %s eine numerische PIN, diese muss kopiert und in <b>c:geo</b> eingefügt werden. Das ist alles.</string> <!-- cache --> <plurals name="cache_counts"> @@ -1066,8 +1082,6 @@ <string name="twitter">Twitter: <a href="">@android_GC</a></string> <string name="nutshellmanual">Benutzung: <a href="">c:geo Kurzanleitung</a></string> <string name="about_twitter">Soll jeder neue Fund auf Twitter veröffentlicht werden, wenn er über <b>c:geo</b> geloggt wird?</string> - <string name="about_auth_1">Der folgende Prozess erlaubt es <b>c:geo</b> auf den persönlichen Twitter-Account zuzugreifen, wenn zugestimmt wird.</string> - <string name="about_auth_2">Ein Klick auf \"Starte Autorisierung\" öffnet eine Twitter-Seite in einem Browserfenster. Durch die Anmeldung und die Bestätigung wird <b>c:geo</b> ermöglicht, auf den persönlichen Twitter-Account zuzugreifen. Wird dies bestätigt, nennt Twitter eine numerische PIN, diese muss kopiert und in <b>c:geo</b> eingefügt werden. Das ist alles.</string> <!-- status --> <string name="status_new_release" tools:ignore="UnusedResources">Neuer Release verfügbar.\nKlicken zum Installieren.</string> diff --git a/main/res/values-fr/strings.xml b/main/res/values-fr/strings.xml index 12d59a7..9f25083 100644 --- a/main/res/values-fr/strings.xml +++ b/main/res/values-fr/strings.xml @@ -371,8 +371,6 @@ <string name="init_gc_activate">Utiliser Geocaching.com pour la carte active et les recherches.</string> <string name="init_oc">opencaching.de</string> <string name="init_oc_activate">Utiliser opencaching.de pour la carte active et les recherches.</string> - <string name="init_oc_username_description">Entrer votre nom d\'utilisateur opencaching.de afin de pouvoir marquer vos trouvailles.</string> - <string name="init_oc_username">Entrer votre nom d\'utilisateur</string> <string name="init_gcvote">GCvote.com</string> <string name="init_twitter">Twitter</string> <string name="init_username">Identifiant</string> diff --git a/main/res/values-it/strings.xml b/main/res/values-it/strings.xml index 00551f5..98fdf5f 100644 --- a/main/res/values-it/strings.xml +++ b/main/res/values-it/strings.xml @@ -367,8 +367,6 @@ <string name="init_gc_activate">Attiva Geocaching.com su mappa live e nelle ricerche</string> <string name="init_oc">opencaching.de</string> <string name="init_oc_activate">Attiva opencaching.de su mappa live e nelle ricerche</string> - <string name="init_oc_username_description">Inserisci il tuo utente opencaching.de per marcare i tuoi ritrovamenti.</string> - <string name="init_oc_username">Inserisci nome utente</string> <string name="init_gcvote">GCvote.com</string> <string name="init_twitter">Twitter</string> <string name="init_username">Utente</string> diff --git a/main/res/values-ja/strings.xml b/main/res/values-ja/strings.xml index 4bb15a2..b88577b 100644 --- a/main/res/values-ja/strings.xml +++ b/main/res/values-ja/strings.xml @@ -345,8 +345,6 @@ <string name="init_geocaching">Geocaching.com</string> <string name="init_oc">opencaching.de</string> <string name="init_oc_activate">オンライン地図や検索でopencaching.deも使用する</string> - <string name="init_oc_username_description">見つけたキャッシュなどをマークするにはopencaching.deのユーザ名を入力してください。</string> - <string name="init_oc_username">ユーザ名</string> <string name="init_gcvote">GCvote.com</string> <string name="init_twitter">Twitter</string> <string name="init_username">ユーザ名</string> diff --git a/main/res/values-nl/strings.xml b/main/res/values-nl/strings.xml index 4eb1bc6..c827848 100644 --- a/main/res/values-nl/strings.xml +++ b/main/res/values-nl/strings.xml @@ -347,8 +347,6 @@ <string name="init_geocaching">Geocaching.com</string> <string name="init_oc">opencaching.de</string> <string name="init_oc_activate">Activeer opencaching.de op live-kaart en in zoekopdrachten.</string> - <string name="init_oc_username_description">Vul je opencaching.de gebruikersnaam in op caches als gevonden te markeren.</string> - <string name="init_oc_username">Vul gebruikersnaam in</string> <string name="init_gcvote">GCvote.com</string> <string name="init_twitter">Twitter</string> <string name="init_username">Gebruikersnaam</string> diff --git a/main/res/values-pl/strings.xml b/main/res/values-pl/strings.xml index 50a383f..e736bbb 100644 --- a/main/res/values-pl/strings.xml +++ b/main/res/values-pl/strings.xml @@ -364,8 +364,6 @@ <string name="init_gc_activate">Aktywuj Geocaching.com na aktualnej mapie i w wyszukiwaniu</string> <string name="init_oc">opencaching.de</string> <string name="init_oc_activate">Aktywuj opencaching.de na mapie Live i w wyszukiwaniu</string> - <string name="init_oc_username_description">Wpisz swoją nazwę użytkownika opencaching.de w celu umożliwienia zaznaczania znalezionych przez Ciebie skrzynek.</string> - <string name="init_oc_username">Wpisz swoją nazwę użytkownika</string> <string name="init_gcvote">GCvote.com</string> <string name="init_twitter">Twitter</string> <string name="init_username">Nazwa użytkownika</string> diff --git a/main/res/values-sv/strings.xml b/main/res/values-sv/strings.xml index 51bee26..8501cf7 100644 --- a/main/res/values-sv/strings.xml +++ b/main/res/values-sv/strings.xml @@ -371,8 +371,6 @@ <string name="init_gc_activate">Aktivera Geocaching.com i live-kartor och sökningar</string> <string name="init_oc">opencaching.de</string> <string name="init_oc_activate">Aktivera opencaching.de i live-kartor och sökningar</string> - <string name="init_oc_username_description">Ange användarnamn till opencaching.de för att kunna markera dina hittade cacher.</string> - <string name="init_oc_username">Ange ditt användarnamn</string> <string name="init_gcvote">GCvote.com</string> <string name="init_twitter">Twitter</string> <string name="init_username">Användare</string> diff --git a/main/res/values/.gitignore b/main/res/values/.gitignore new file mode 100644 index 0000000..1f65bef --- /dev/null +++ b/main/res/values/.gitignore @@ -0,0 +1 @@ +/ocde_okapi.xml diff --git a/main/res/values/strings.xml b/main/res/values/strings.xml index 4d9202e..43f87ea 100644 --- a/main/res/values/strings.xml +++ b/main/res/values/strings.xml @@ -371,8 +371,8 @@ <string name="init_gc_activate">Activate Geocaching.com on live-map and in searches</string> <string name="init_oc">opencaching.de</string> <string name="init_oc_activate">Activate opencaching.de on live-map and in searches</string> - <string name="init_oc_username_description">Enter your opencaching.de user name in order to allow marking your finds.</string> - <string name="init_oc_username">Enter your user name</string> + <string name="init_oc_de_description">Authorize c:geo with opencaching.de to search for caches and access/filter your found caches.</string> + <string name="init_register_oc_de">Authorize c:geo</string> <string name="init_gcvote">GCvote.com</string> <string name="init_twitter">Twitter</string> <string name="init_username">Username</string> @@ -486,8 +486,7 @@ <string name="sendToCgeo_download_fail">c:geo failed to download caches. No internet connection or send2c:geo is down.</string> <string name="sendToCgeo_no_registration">c:geo failed to download caches. Registration for send2c:geo expired. Please register in settings.</string> - - <!-- auth --> + <!-- auth twitter --> <string name="auth_twitter">Twitter</string> <string name="auth_authorize">Authorize c:geo</string> <string name="auth_start">Start authorization</string> @@ -498,6 +497,22 @@ <string name="auth_dialog_pin_title">PIN code</string> <string name="auth_dialog_pin_message">Please type in PIN code provided by the Twitter website. It is mandatory to complete the authorization.</string> <string name="auth_dialog_completed">c:geo is now authorized to post on Twitter.</string> + <string name="about_auth_1">The following process allows <b>c:geo</b> to access Twitter - if agreed.</string> + <string name="about_auth_2">A click on the \"authorize c:geo\" button will start the process. This process will open up a web browser with a Twitter page. Login on this page and allow <b>c:geo</b> to access your account. If this is accepted, Twitter will show up a numeric PIN code. This PIN must be pasted into <b>c:geo</b> and confirmed. That\'s all.</string> + + <!-- auth opencaching --> + <string name="auth_ocde">opencaching.de</string> + <string name="auth_authorize_oc">Authorize c:geo</string> + <string name="auth_start_oc">Start authorization</string> + <string name="auth_again_oc">Start again</string> + <string name="auth_pin_hint_oc">PIN assigned by %s</string> + <string name="auth_finish_oc">Finish</string> + <string name="auth_dialog_wait_oc">Waiting for %s…</string> + <string name="auth_dialog_pin_title_oc">PIN code</string> + <string name="auth_dialog_pin_message_oc">Please type in PIN code provided by the %s website. It is mandatory to complete the authorization.</string> + <string name="auth_dialog_completed_oc">c:geo is now authorized to interact with %s.</string> + <string name="about_auth_1_oc">The following process allows <b>c:geo</b> to access %s - if agreed.</string> + <string name="about_auth_2_oc">A click on the \"authorize c:geo\" button will start the process. This process will open up a web browser with a %s page. Login on this page and allow <b>c:geo</b> to access your account. If this is accepted, %s will show up a numeric PIN code. This PIN must be pasted into <b>c:geo</b> and confirmed. That\'s all.</string> <!-- cache --> <plurals name="cache_counts"> @@ -1070,8 +1085,6 @@ <string name="nutshellmanual">Manual: <a href="">c:geo in a Nutshell</a></string> <string name="market">Android: <a href="">c:geo on Google Play</a></string> <string name="about_twitter">Should <b>c:geo</b> publish a new status on Twitter every time you log a cache?</string> - <string name="about_auth_1">The following process allows <b>c:geo</b> to access Twitter - if agreed.</string> - <string name="about_auth_2">A click on the \"authorize c:geo\" button will start the process. This process will open up a web browser with a Twitter page. Login on this page and allow <b>c:geo</b> to access your account. If this is accepted, Twitter will show up a numeric PIN code. This PIN must be pasted into <b>c:geo</b> and confirmed. That\'s all.</string> <!-- status (used via string based resource loading) --> <string name="status_new_release" tools:ignore="UnusedResources">New release available.\nClick to install.</string> diff --git a/main/src/cgeo/geocaching/CacheDetailActivity.java b/main/src/cgeo/geocaching/CacheDetailActivity.java index fe6693b..33a6504 100644 --- a/main/src/cgeo/geocaching/CacheDetailActivity.java +++ b/main/src/cgeo/geocaching/CacheDetailActivity.java @@ -117,7 +117,7 @@ import java.util.regex.Pattern; * e.g. details, description, logs, waypoints, inventory... */ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailActivity.Page> - implements EditNoteDialogListener { + implements EditNoteDialogListener { private static final int MENU_FIELD_COPY = 1; private static final int MENU_FIELD_TRANSLATE = 2; @@ -259,6 +259,23 @@ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailAc finish(); return; } + } else if (uriHost.contains("opencaching.de")) { + if (uriPath != null && uriPath.startsWith("/oc")) { + geocode = uriPath.substring(1).toUpperCase(Locale.US); + } else { + geocode = uri.getQueryParameter("wp"); + if (StringUtils.isNotBlank(geocode)) { + geocode = geocode.toUpperCase(Locale.US); + } else { + showToast(res.getString(R.string.err_detail_open)); + finish(); + return; + } + } + } else { + showToast(res.getString(R.string.err_detail_open)); + finish(); + return; } } @@ -1472,7 +1489,7 @@ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailAc @Override public void run() { - handler.sendEmptyMessage(GCConnector.addToWatchlist(cache) ? 1 : -1); + handler.sendEmptyMessage(ConnectorFactory.getConnector(cache).addToWatchlist(cache) ? 1 : -1); } } @@ -1486,7 +1503,7 @@ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailAc @Override public void run() { - handler.sendEmptyMessage(GCConnector.removeFromWatchlist(cache) ? 1 : -1); + handler.sendEmptyMessage(ConnectorFactory.getConnector(cache).removeFromWatchlist(cache) ? 1 : -1); } } @@ -2242,8 +2259,7 @@ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailAc } /** - * Read the position of the cursor pointed to by this holder. - * <br/> + * Read the position of the cursor pointed to by this holder. <br/> * This must be called by the UI thread. * * @return the cursor position @@ -2253,11 +2269,11 @@ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailAc } /** - * Set the position of the cursor pointed to by this holder. - * <br/> + * Set the position of the cursor pointed to by this holder. <br/> * This must be called by the UI thread. * - * @param position the cursor position + * @param position + * the cursor position */ public void setPosition(final int position) { this.position = position; diff --git a/main/src/cgeo/geocaching/Geocache.java b/main/src/cgeo/geocaching/Geocache.java index 304f940..ac1c9b1 100644 --- a/main/src/cgeo/geocaching/Geocache.java +++ b/main/src/cgeo/geocaching/Geocache.java @@ -5,6 +5,7 @@ import cgeo.geocaching.activity.ActivityMixin; import cgeo.geocaching.activity.IAbstractActivity; import cgeo.geocaching.connector.ConnectorFactory; import cgeo.geocaching.connector.IConnector; +import cgeo.geocaching.connector.ILoggingManager; import cgeo.geocaching.connector.capability.ISearchByCenter; import cgeo.geocaching.connector.capability.ISearchByGeocode; import cgeo.geocaching.connector.gc.GCConnector; @@ -455,7 +456,7 @@ public class Geocache implements ICache, IWaypoint { } public void logVisit(final IAbstractActivity fromActivity) { - if (StringUtils.isBlank(cacheId)) { + if (!getConnector().canLog(this)) { fromActivity.showToast(((Activity) fromActivity).getResources().getString(R.string.err_cannot_log_visit)); return; } @@ -562,6 +563,10 @@ public class Geocache implements ICache, IWaypoint { return getConnector().supportsLogging(); } + public boolean supportsLogImages() { + return getConnector().supportsLogImages(); + } + public boolean supportsOwnCoordinates() { return getConnector().supportsOwnCoordinates(); } @@ -570,6 +575,10 @@ public class Geocache implements ICache, IWaypoint { return getConnector().getCacheRealm(); } + public ILoggingManager getLoggingManager(Activity activity) { + return getConnector().getLoggingManager(activity, this); + } + @Override public float getDifficulty() { return difficulty; diff --git a/main/src/cgeo/geocaching/MainActivity.java b/main/src/cgeo/geocaching/MainActivity.java index 9b23554..4393eda 100644 --- a/main/src/cgeo/geocaching/MainActivity.java +++ b/main/src/cgeo/geocaching/MainActivity.java @@ -697,6 +697,10 @@ public class MainActivity extends AbstractActivity { return; } + if (!Settings.isGCConnectorActive()) { + return; + } + // login final StatusCode status = Login.login(); diff --git a/main/src/cgeo/geocaching/Settings.java b/main/src/cgeo/geocaching/Settings.java index b5c8a6e..65283da 100644 --- a/main/src/cgeo/geocaching/Settings.java +++ b/main/src/cgeo/geocaching/Settings.java @@ -40,8 +40,8 @@ import java.util.Locale; */ public final class Settings { - private static final String KEY_TEMP_TOKEN_SECRET = "temp-token-secret"; - private static final String KEY_TEMP_TOKEN_PUBLIC = "temp-token-public"; + private static final String KEY_TEMP_TWITTER_TOKEN_SECRET = "temp-token-secret"; + private static final String KEY_TEMP_TWITTER_TOKEN_PUBLIC = "temp-token-public"; private static final String KEY_HELP_SHOWN = "helper"; private static final String KEY_ANYLONGITUDE = "anylongitude"; private static final String KEY_ANYLATITUDE = "anylatitude"; @@ -110,9 +110,14 @@ public final class Settings { private static final String KEY_PLAIN_LOGS = "plainLogs"; private static final String KEY_NATIVE_UA = "nativeUa"; private static final String KEY_MAP_DIRECTORY = "mapDirectory"; + private static final String KEY_CONNECTOR_GC_ACTIVE = "connectorGCActive"; private static final String KEY_CONNECTOR_OC_ACTIVE = "connectorOCActive"; - private static final String KEY_CONNECTOR_OC_USER = "connectorOCUser"; private static final String KEY_LOG_IMAGE_SCALE = "logImageScale"; + private static final String KEY_OCDE_TOKEN_SECRET = "ocde_tokensecret"; + private static final String KEY_OCDE_TOKEN_PUBLIC = "ocde_tokenpublic"; + private static final String KEY_TEMP_OCDE_TOKEN_SECRET = "ocde-temp-token-secret"; + private static final String KEY_TEMP_OCDE_TOKEN_PUBLIC = "ocde-temp-token-public"; + private final static int unitsMetric = 1; @@ -163,8 +168,8 @@ public final class Settings { final SharedPreferences old = cgeoapplication.getInstance().getSharedPreferences(oldPreferencesName, Context.MODE_PRIVATE); final Editor e = sharedPrefs.edit(); - e.putString(KEY_TEMP_TOKEN_SECRET, old.getString(KEY_TEMP_TOKEN_SECRET, null)); - e.putString(KEY_TEMP_TOKEN_PUBLIC, old.getString(KEY_TEMP_TOKEN_PUBLIC, null)); + e.putString(KEY_TEMP_TWITTER_TOKEN_SECRET, old.getString(KEY_TEMP_TWITTER_TOKEN_SECRET, null)); + e.putString(KEY_TEMP_TWITTER_TOKEN_PUBLIC, old.getString(KEY_TEMP_TWITTER_TOKEN_PUBLIC, null)); e.putBoolean(KEY_HELP_SHOWN, old.getInt(KEY_HELP_SHOWN, 0) != 0); e.putFloat(KEY_ANYLONGITUDE, old.getFloat(KEY_ANYLONGITUDE, 0)); e.putFloat(KEY_ANYLATITUDE, old.getFloat(KEY_ANYLATITUDE, 0)); @@ -284,6 +289,20 @@ public final class Settings { }); } + public static boolean isGCConnectorActive() { + return sharedPrefs.getBoolean(KEY_CONNECTOR_GC_ACTIVE, true); + } + + public static boolean setGCConnectorActive(final boolean isActive) { + return editSharedSettings(new PrefRunnable() { + + @Override + public void edit(Editor edit) { + edit.putBoolean(KEY_CONNECTOR_GC_ACTIVE, isActive); + } + }); + } + public static boolean isPremiumMember() { // Basic Member, Premium Member, ??? String memberStatus = Settings.getMemberStatus(); @@ -325,26 +344,44 @@ public final class Settings { }); } - public static String getOCConnectorUserName() { - String ocConnectorUser = sharedPrefs.getString(KEY_CONNECTOR_OC_USER, null); - if (StringUtils.isBlank(ocConnectorUser)) { - return StringUtils.EMPTY; - } - return ocConnectorUser; + public static String getOCDETokenPublic() { + return sharedPrefs.getString(KEY_OCDE_TOKEN_PUBLIC, ""); } - public static boolean setOCConnectorUserName(final String userName) { - return editSharedSettings(new PrefRunnable() { + public static String getOCDETokenSecret() { + return sharedPrefs.getString(KEY_OCDE_TOKEN_SECRET, ""); + } + + public static void setOCDETokens(final String tokenPublic, final String tokenSecret, boolean enableOcDe) { + editSharedSettings(new PrefRunnable() { @Override public void edit(Editor edit) { - if (StringUtils.isBlank(userName)) { - edit.remove(KEY_CONNECTOR_OC_USER); - } else { - edit.putString(KEY_CONNECTOR_OC_USER, userName); + edit.putString(KEY_OCDE_TOKEN_PUBLIC, tokenPublic); + edit.putString(KEY_OCDE_TOKEN_SECRET, tokenSecret); + if (tokenPublic != null) { + edit.remove(KEY_TEMP_OCDE_TOKEN_PUBLIC); + edit.remove(KEY_TEMP_OCDE_TOKEN_SECRET); } } }); + setOCConnectorActive(enableOcDe); + } + + public static void setOCDETempTokens(final String tokenPublic, final String tokenSecret) { + editSharedSettings(new PrefRunnable() { + @Override + public void edit(Editor edit) { + edit.putString(KEY_TEMP_OCDE_TOKEN_PUBLIC, tokenPublic); + edit.putString(KEY_TEMP_OCDE_TOKEN_SECRET, tokenSecret); + } + }); + } + + public static ImmutablePair<String, String> getTempOCDEToken() { + String tokenPublic = sharedPrefs.getString(KEY_TEMP_OCDE_TOKEN_PUBLIC, null); + String tokenSecret = sharedPrefs.getString(KEY_TEMP_OCDE_TOKEN_SECRET, null); + return new ImmutablePair<String, String>(tokenPublic, tokenSecret); } public static boolean isGCvoteLogin() { @@ -1122,8 +1159,8 @@ public final class Settings { edit.putString(KEY_TWITTER_TOKEN_PUBLIC, tokenPublic); edit.putString(KEY_TWITTER_TOKEN_SECRET, tokenSecret); if (tokenPublic != null) { - edit.remove(KEY_TEMP_TOKEN_PUBLIC); - edit.remove(KEY_TEMP_TOKEN_SECRET); + edit.remove(KEY_TEMP_TWITTER_TOKEN_PUBLIC); + edit.remove(KEY_TEMP_TWITTER_TOKEN_SECRET); } } }); @@ -1134,15 +1171,15 @@ public final class Settings { editSharedSettings(new PrefRunnable() { @Override public void edit(Editor edit) { - edit.putString(KEY_TEMP_TOKEN_PUBLIC, tokenPublic); - edit.putString(KEY_TEMP_TOKEN_SECRET, tokenSecret); + edit.putString(KEY_TEMP_TWITTER_TOKEN_PUBLIC, tokenPublic); + edit.putString(KEY_TEMP_TWITTER_TOKEN_SECRET, tokenSecret); } }); } public static ImmutablePair<String, String> getTempToken() { - String tokenPublic = sharedPrefs.getString(KEY_TEMP_TOKEN_PUBLIC, null); - String tokenSecret = sharedPrefs.getString(KEY_TEMP_TOKEN_SECRET, null); + String tokenPublic = sharedPrefs.getString(KEY_TEMP_TWITTER_TOKEN_PUBLIC, null); + String tokenSecret = sharedPrefs.getString(KEY_TEMP_TWITTER_TOKEN_SECRET, null); return new ImmutablePair<String, String>(tokenPublic, tokenSecret); } diff --git a/main/src/cgeo/geocaching/SettingsActivity.java b/main/src/cgeo/geocaching/SettingsActivity.java index f09f7d6..aa163ad 100644 --- a/main/src/cgeo/geocaching/SettingsActivity.java +++ b/main/src/cgeo/geocaching/SettingsActivity.java @@ -5,6 +5,7 @@ import cgeo.geocaching.apps.cache.navi.NavigationAppFactory; import cgeo.geocaching.apps.cache.navi.NavigationAppFactory.NavigationAppsEnum; import cgeo.geocaching.compatibility.Compatibility; import cgeo.geocaching.connector.gc.Login; +import cgeo.geocaching.connector.oc.OCAuthorizationActivity; import cgeo.geocaching.enumerations.StatusCode; import cgeo.geocaching.files.SimpleDirChooser; import cgeo.geocaching.maps.MapProviderFactory; @@ -169,7 +170,6 @@ public class SettingsActivity extends AbstractActivity { ((EditText) findViewById(R.id.username)).setText(""); ((EditText) findViewById(R.id.password)).setText(""); ((EditText) findViewById(R.id.passvote)).setText(""); - ((EditText) findViewById(R.id.oc_username)).setText(""); if (saveValues()) { showToast(res.getString(R.string.init_cleared)); @@ -213,6 +213,15 @@ public class SettingsActivity extends AbstractActivity { public void init() { // geocaching.com settings + final CheckBox gcCheck = (CheckBox) findViewById(R.id.gc_option); + gcCheck.setChecked(Settings.isGCConnectorActive()); + gcCheck.setOnClickListener(new View.OnClickListener() { + + @Override + public void onClick(View v) { + Settings.setGCConnectorActive(gcCheck.isChecked()); + } + }); final ImmutablePair<String, String> login = Settings.getLogin(); if (login != null) { ((EditText) findViewById(R.id.username)).setText(login.left); @@ -242,10 +251,9 @@ public class SettingsActivity extends AbstractActivity { Settings.setOCConnectorActive(ocCheck.isChecked()); } }); - EditText ocUserEdit = (EditText) findViewById(R.id.oc_username); - if (ocUserEdit.getText().length() == 0) { - ocUserEdit.setText(Settings.getOCConnectorUserName()); - } + + Button checkOCUser = (Button) findViewById(R.id.register_oc_de); + checkOCUser.setOnClickListener(new OCDEAuthorizeCgeoListener()); // gcvote settings final ImmutablePair<String, String> gcvoteLogin = Settings.getGCvoteLogin(); @@ -829,7 +837,6 @@ public class SettingsActivity extends AbstractActivity { String signatureNew = ((EditText) findViewById(R.id.signature)).getText().toString(); String mapDirectoryNew = StringUtils.trimToEmpty(((EditText) findViewById(R.id.map_directory)).getText().toString()); String themesDirectoryNew = StringUtils.trimToEmpty(((EditText) findViewById(R.id.themefolder)).getText().toString()); - String ocUserName = StringUtils.trimToEmpty(((EditText) findViewById(R.id.oc_username)).getText().toString()); String altitudeNew = StringUtils.trimToNull(((EditText) findViewById(R.id.altitude)).getText().toString()); int altitudeNewInt = parseNumber(altitudeNew, 0); @@ -843,7 +850,6 @@ public class SettingsActivity extends AbstractActivity { final boolean status4 = Settings.setAltCorrection(altitudeNewInt); final boolean status5 = Settings.setMapFileDirectory(mapDirectoryNew); final boolean status6 = Settings.setCustomRenderThemeBaseFolder(themesDirectoryNew); - final boolean status7 = Settings.setOCConnectorUserName(ocUserName); Settings.setShowWaypointsThreshold(waypointThreshold); String importNew = StringUtils.trimToEmpty(((EditText) findViewById(R.id.gpx_importdir)).getText().toString()); @@ -851,7 +857,7 @@ public class SettingsActivity extends AbstractActivity { Settings.setGpxImportDir(importNew); Settings.setGpxExportDir(exportNew); - return status1 && status2 && status3 && status4 && status5 && status6 && status7; + return status1 && status2 && status3 && status4 && status5 && status6; } /** @@ -920,6 +926,15 @@ public class SettingsActivity extends AbstractActivity { } } + private class OCDEAuthorizeCgeoListener implements View.OnClickListener { + + @Override + public void onClick(View v) { + Intent authIntent = new Intent(SettingsActivity.this, OCAuthorizationActivity.class); + startActivity(authIntent); + } + } + private class WebAuthListener implements View.OnClickListener { @Override diff --git a/main/src/cgeo/geocaching/VisitCacheActivity.java b/main/src/cgeo/geocaching/VisitCacheActivity.java index c19cceb..e99da8d 100644 --- a/main/src/cgeo/geocaching/VisitCacheActivity.java +++ b/main/src/cgeo/geocaching/VisitCacheActivity.java @@ -1,14 +1,13 @@ package cgeo.geocaching; -import cgeo.geocaching.connector.gc.GCParser; -import cgeo.geocaching.connector.gc.Login; +import cgeo.geocaching.connector.ILoggingManager; +import cgeo.geocaching.connector.ImageResult; +import cgeo.geocaching.connector.LogResult; import cgeo.geocaching.enumerations.LoadFlags; import cgeo.geocaching.enumerations.LogType; import cgeo.geocaching.enumerations.LogTypeTrackable; import cgeo.geocaching.enumerations.StatusCode; import cgeo.geocaching.gcvote.GCVote; -import cgeo.geocaching.loaders.UrlLoader; -import cgeo.geocaching.network.Parameters; import cgeo.geocaching.twitter.Twitter; import cgeo.geocaching.ui.Formatter; import cgeo.geocaching.ui.dialog.DateDialog; @@ -20,7 +19,6 @@ import cgeo.geocaching.utils.LogTemplateProvider.LogContext; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.tuple.ImmutablePair; import android.app.Activity; import android.app.AlertDialog; @@ -31,8 +29,6 @@ import android.content.DialogInterface.OnClickListener; import android.content.Intent; import android.net.Uri; import android.os.Bundle; -import android.support.v4.app.LoaderManager; -import android.support.v4.content.Loader; import android.util.SparseArray; import android.view.LayoutInflater; import android.view.Menu; @@ -51,7 +47,7 @@ import java.util.Date; import java.util.List; import java.util.Locale; -public class VisitCacheActivity extends AbstractLoggingActivity implements DateDialog.DateDialogParent, LoaderManager.LoaderCallbacks<String> { +public class VisitCacheActivity extends AbstractLoggingActivity implements DateDialog.DateDialogParent { static final String EXTRAS_GEOCODE = "geocode"; static final String EXTRAS_ID = "id"; @@ -71,7 +67,6 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD private String geocode = null; private String text = null; private List<LogType> possibleLogTypes = new ArrayList<LogType>(); - private String[] viewstates = null; private List<TrackableLog> trackables = null; private Button postButton = null; private CheckBox tweetCheck = null; @@ -79,6 +74,8 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD private boolean tbChanged = false; private SparseArray<TrackableLog> actionButtons; + private ILoggingManager loggingManager; + // Data to be saved while reconfiguring private double rating; private LogType typeSelected; @@ -87,30 +84,16 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD private String imageDescription; private Uri imageUri; - @Override - public Loader<String> onCreateLoader(final int id, final Bundle args) { - if (!Settings.isLogin()) { // allow offline logging - showToast(res.getString(R.string.err_login)); - return null; - } - return new UrlLoader(getBaseContext(), "http://www.geocaching.com/seek/log.aspx", new Parameters("ID", cacheid)); - } - @Override - public void onLoaderReset(final Loader<String> loader) { - // Nothing to do - } + public void onLoadFinished() { - @Override - public void onLoadFinished(final Loader<String> loader, final String page) { - if (page == null) { + if (loggingManager.hasLoaderError()) { showErrorLoadingData(); return; } - viewstates = Login.getViewstates(page); - trackables = GCParser.parseTrackableLog(page); - possibleLogTypes = GCParser.parseTypes(page); + trackables = loggingManager.getTrackables(); + possibleLogTypes = loggingManager.getPossibleLogTypes(); if (possibleLogTypes.isEmpty()) { showErrorLoadingData(); @@ -229,7 +212,7 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD if (!postButton.isEnabled()) { return res.getString(R.string.log_post_not_possible); } - if (typeSelected != LogType.FOUND_IT || !Settings.isGCvoteLogin()) { + if (typeSelected != LogType.FOUND_IT || !Settings.isGCvoteLogin() || !cache.supportsGCVote()) { return res.getString(R.string.log_post); } if (rating == 0) { @@ -295,7 +278,7 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD } } updatePostButtonText(); - setImageButtonText(); + updateImageButton(); enablePostButton(false); final Button typeButton = (Button) findViewById(R.id.type); @@ -347,7 +330,9 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD } }); - getSupportLoaderManager().initLoader(0, null, this); + loggingManager = cache.getLoggingManager(this); + + loggingManager.init(); } private void setDefaultValues() { @@ -393,7 +378,7 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD final EditText logView = (EditText) findViewById(R.id.log); logView.setText(StringUtils.EMPTY); - setImageButtonText(); + updateImageButton(); showToast(res.getString(R.string.info_log_cleared)); } @@ -433,7 +418,7 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD public boolean onPrepareOptionsMenu(Menu menu) { super.onPrepareOptionsMenu(menu); - final boolean voteAvailable = Settings.isGCvoteLogin() && typeSelected == LogType.FOUND_IT && StringUtils.isNotBlank(cache.getGuid()); + final boolean voteAvailable = Settings.isGCvoteLogin() && typeSelected == LogType.FOUND_IT && StringUtils.isNotBlank(cache.getGuid()) && cache.supportsGCVote(); menu.findItem(SUBMENU_VOTE).setVisible(voteAvailable); return true; @@ -536,11 +521,9 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD protected StatusCode doInBackgroundInternal(final String[] logTexts) { final String log = logTexts[0]; try { - final ImmutablePair<StatusCode, String> postResult = GCParser.postLog(geocode, cacheid, viewstates, typeSelected, - date.get(Calendar.YEAR), (date.get(Calendar.MONTH) + 1), date.get(Calendar.DATE), - log, trackables); + final LogResult logResult = loggingManager.postLog(cache, typeSelected, date, log, trackables); - if (postResult.left == StatusCode.NO_ERROR) { + if (logResult.getPostLogResult() == StatusCode.NO_ERROR) { final LogEntry logNow = new LogEntry(date, typeSelected, log); cache.getLogs().add(0, logNow); @@ -560,17 +543,17 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD } if (StringUtils.isNotBlank(imageUri.getPath())) { - ImmutablePair<StatusCode, String> imageResult = GCParser.uploadLogImage(postResult.right, imageCaption, imageDescription, imageUri); - final String uploadedImageUrl = imageResult.right; + ImageResult imageResult = loggingManager.postLogImage(logResult.getLogId(), imageCaption, imageDescription, imageUri); + final String uploadedImageUrl = imageResult.getImageUri(); if (StringUtils.isNotEmpty(uploadedImageUrl)) { logNow.addLogImage(new Image(uploadedImageUrl, imageCaption, imageDescription)); cgData.saveChangedCache(cache); } - return imageResult.left; + return imageResult.getPostResult(); } } - return postResult.left; + return logResult.getPostLogResult(); } catch (Exception e) { Log.e("cgeovisit.postLogFn", e); } @@ -705,14 +688,19 @@ public class VisitCacheActivity extends AbstractLoggingActivity implements DateD // Image capture failed, advise user showToast(getResources().getString(R.string.err_select_logimage_failed)); } - setImageButtonText(); + updateImageButton(); } } - private void setImageButtonText() { + private void updateImageButton() { final Button imageButton = (Button) findViewById(R.id.image_btn); - imageButton.setText(StringUtils.isNotBlank(imageUri.getPath()) ? + if (cache.supportsLogImages()) { + imageButton.setVisibility(View.VISIBLE); + imageButton.setText(StringUtils.isNotBlank(imageUri.getPath()) ? res.getString(R.string.log_image_edit) : res.getString(R.string.log_image_attach)); + } else { + imageButton.setVisibility(View.GONE); + } } } diff --git a/main/src/cgeo/geocaching/connector/AbstractConnector.java b/main/src/cgeo/geocaching/connector/AbstractConnector.java index 413291c..905382f 100644 --- a/main/src/cgeo/geocaching/connector/AbstractConnector.java +++ b/main/src/cgeo/geocaching/connector/AbstractConnector.java @@ -6,6 +6,8 @@ import cgeo.geocaching.geopoint.Geopoint; import org.apache.commons.lang3.StringUtils; +import android.app.Activity; + public abstract class AbstractConnector implements IConnector { @Override @@ -19,6 +21,16 @@ public abstract class AbstractConnector implements IConnector { } @Override + public boolean addToWatchlist(Geocache cache) { + return false; + } + + @Override + public boolean removeFromWatchlist(Geocache cache) { + return false; + } + + @Override public boolean supportsOwnCoordinates() { return false; } @@ -54,6 +66,21 @@ public abstract class AbstractConnector implements IConnector { } @Override + public boolean supportsLogImages() { + return false; + } + + @Override + public boolean canLog(Geocache cache) { + return false; + } + + @Override + public ILoggingManager getLoggingManager(Activity activity, Geocache cache) { + return new NoLoggingManager(); + } + + @Override public String getLicenseText(final Geocache cache) { return null; } diff --git a/main/src/cgeo/geocaching/connector/ConnectorFactory.java b/main/src/cgeo/geocaching/connector/ConnectorFactory.java index 561bae2..50f56af 100644 --- a/main/src/cgeo/geocaching/connector/ConnectorFactory.java +++ b/main/src/cgeo/geocaching/connector/ConnectorFactory.java @@ -1,14 +1,15 @@ package cgeo.geocaching.connector; import cgeo.geocaching.ICache; +import cgeo.geocaching.R; import cgeo.geocaching.SearchResult; import cgeo.geocaching.Trackable; import cgeo.geocaching.connector.capability.ISearchByCenter; import cgeo.geocaching.connector.capability.ISearchByViewPort; import cgeo.geocaching.connector.gc.GCConnector; import cgeo.geocaching.connector.oc.OCApiConnector; +import cgeo.geocaching.connector.oc.OCApiLiveConnector; import cgeo.geocaching.connector.oc.OCConnector; -import cgeo.geocaching.connector.oc.OCXMLApiConnector; import cgeo.geocaching.connector.ox.OXConnector; import cgeo.geocaching.geopoint.Viewport; @@ -21,7 +22,7 @@ public final class ConnectorFactory { private static final UnknownConnector UNKNOWN_CONNECTOR = new UnknownConnector(); private static final IConnector[] connectors = new IConnector[] { GCConnector.getInstance(), - new OCXMLApiConnector("OpenCaching.DE", "www.opencaching.de", "OC"), + new OCApiLiveConnector("Opencaching.de", "www.opencaching.de", "OC", R.string.oc_de_okapi_consumer_key, R.string.oc_de_okapi_consumer_secret), new OCConnector("OpenCaching.CZ", "www.opencaching.cz", "OZ"), new OCApiConnector("OpenCaching.CO.UK", "www.opencaching.org.uk", "OK", "arU4okouc4GEjMniE2fq"), new OCConnector("OpenCaching.ES", "www.opencachingspain.es", "OC"), diff --git a/main/src/cgeo/geocaching/connector/IConnector.java b/main/src/cgeo/geocaching/connector/IConnector.java index 9169b4a..011c507 100644 --- a/main/src/cgeo/geocaching/connector/IConnector.java +++ b/main/src/cgeo/geocaching/connector/IConnector.java @@ -5,6 +5,8 @@ import cgeo.geocaching.ICache; import cgeo.geocaching.enumerations.CacheRealm; import cgeo.geocaching.geopoint.Geopoint; +import android.app.Activity; + public interface IConnector { /** * get name for display (currently only used in links) @@ -45,6 +47,22 @@ public interface IConnector { public boolean supportsWatchList(); /** + * Add the cache to the watchlist + * + * @param cache + * @return True - success/False - failure + */ + public boolean addToWatchlist(Geocache cache); + + /** + * Remove the cache from the watchlist + * + * @param cache + * @return True - success/False - failure + */ + public boolean removeFromWatchlist(Geocache cache); + + /** * enable/disable favorite points controls in cache details * * @return @@ -59,6 +77,20 @@ public interface IConnector { public boolean supportsLogging(); /** + * enable/disable attaching image to log + * + * @return + */ + public boolean supportsLogImages(); + + /** + * Get an ILoggingManager to guide the logging process. + * + * @return + */ + public ILoggingManager getLoggingManager(Activity activity, Geocache cache); + + /** * get host name of the connector server for dynamic loading of data * * @return @@ -159,4 +191,13 @@ public interface IConnector { * @return <code>true</code> if the current user is the cache owner, <code>false</code> otherwise */ public boolean isOwner(final ICache cache); + + /** + * Check if the cache information is complete enough to be + * able to log online. + * + * @param geocache + * @return + */ + public boolean canLog(Geocache geocache); } diff --git a/main/src/cgeo/geocaching/connector/ILoggingManager.java b/main/src/cgeo/geocaching/connector/ILoggingManager.java new file mode 100644 index 0000000..f0029f9 --- /dev/null +++ b/main/src/cgeo/geocaching/connector/ILoggingManager.java @@ -0,0 +1,32 @@ +package cgeo.geocaching.connector; + +import cgeo.geocaching.Geocache; +import cgeo.geocaching.TrackableLog; +import cgeo.geocaching.enumerations.LogType; + +import android.net.Uri; + +import java.util.Calendar; +import java.util.List; + +public interface ILoggingManager { + + LogResult postLog(Geocache cache, + LogType logType, + Calendar date, + String log, + List<TrackableLog> trackableLogs); + + ImageResult postLogImage(String logId, + String imageCaption, + String imageDescription, + Uri imageUri); + + public boolean hasLoaderError(); + + public List<TrackableLog> getTrackables(); + + public List<LogType> getPossibleLogTypes(); + + public void init(); +} diff --git a/main/src/cgeo/geocaching/connector/ImageResult.java b/main/src/cgeo/geocaching/connector/ImageResult.java new file mode 100644 index 0000000..9314cad --- /dev/null +++ b/main/src/cgeo/geocaching/connector/ImageResult.java @@ -0,0 +1,23 @@ +package cgeo.geocaching.connector; + +import cgeo.geocaching.enumerations.StatusCode; + +public class ImageResult { + + private final StatusCode postResult; + private final String imageUri; + + public ImageResult(StatusCode postResult, String imageUri) { + this.postResult = postResult; + this.imageUri = imageUri; + } + + public StatusCode getPostResult() { + return postResult; + } + + public String getImageUri() { + return imageUri; + } + +} diff --git a/main/src/cgeo/geocaching/connector/LogResult.java b/main/src/cgeo/geocaching/connector/LogResult.java new file mode 100644 index 0000000..62111a4 --- /dev/null +++ b/main/src/cgeo/geocaching/connector/LogResult.java @@ -0,0 +1,23 @@ +package cgeo.geocaching.connector; + +import cgeo.geocaching.enumerations.StatusCode; + +public class LogResult { + + private final StatusCode postLogResult; + private final String logId; + + public LogResult(StatusCode postLogResult, String logId) { + this.postLogResult = postLogResult; + this.logId = logId; + } + + public StatusCode getPostLogResult() { + return postLogResult; + } + + public String getLogId() { + return logId; + } + +} diff --git a/main/src/cgeo/geocaching/connector/NoLoggingManager.java b/main/src/cgeo/geocaching/connector/NoLoggingManager.java new file mode 100644 index 0000000..bfea4ca --- /dev/null +++ b/main/src/cgeo/geocaching/connector/NoLoggingManager.java @@ -0,0 +1,46 @@ +package cgeo.geocaching.connector; + +import cgeo.geocaching.Geocache; +import cgeo.geocaching.TrackableLog; +import cgeo.geocaching.enumerations.LogType; +import cgeo.geocaching.enumerations.StatusCode; + +import android.net.Uri; + +import java.util.Calendar; +import java.util.Collections; +import java.util.List; + +public class NoLoggingManager implements ILoggingManager { + + @Override + public void init() { + // nothing to do + } + + @Override + public LogResult postLog(Geocache cache, LogType logType, Calendar date, String log, List<TrackableLog> trackableLogs) { + return new LogResult(StatusCode.LOG_POST_ERROR, ""); + } + + @Override + public ImageResult postLogImage(String logId, String imageCaption, String imageDescription, Uri imageUri) { + return new ImageResult(StatusCode.LOG_POST_ERROR, ""); + } + + @Override + public boolean hasLoaderError() { + return true; + } + + @Override + public List<TrackableLog> getTrackables() { + return Collections.emptyList(); + } + + @Override + public List<LogType> getPossibleLogTypes() { + return Collections.emptyList(); + } + +} diff --git a/main/src/cgeo/geocaching/connector/gc/GCConnector.java b/main/src/cgeo/geocaching/connector/gc/GCConnector.java index a2df060..82bd52a 100644 --- a/main/src/cgeo/geocaching/connector/gc/GCConnector.java +++ b/main/src/cgeo/geocaching/connector/gc/GCConnector.java @@ -7,6 +7,7 @@ import cgeo.geocaching.SearchResult; import cgeo.geocaching.Settings; import cgeo.geocaching.cgData; import cgeo.geocaching.connector.AbstractConnector; +import cgeo.geocaching.connector.ILoggingManager; import cgeo.geocaching.connector.capability.ISearchByCenter; import cgeo.geocaching.connector.capability.ISearchByGeocode; import cgeo.geocaching.connector.capability.ISearchByViewPort; @@ -20,6 +21,8 @@ import cgeo.geocaching.utils.Log; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; +import android.app.Activity; + import java.util.regex.Pattern; public class GCConnector extends AbstractConnector implements ISearchByGeocode, ISearchByCenter, ISearchByViewPort { @@ -82,6 +85,21 @@ public class GCConnector extends AbstractConnector implements ISearchByGeocode, } @Override + public boolean supportsLogImages() { + return true; + } + + @Override + public ILoggingManager getLoggingManager(Activity activity, Geocache cache) { + return new GCLoggingManager(activity, cache); + } + + @Override + public boolean canLog(Geocache cache) { + return StringUtils.isNotBlank(cache.getCacheId()); + } + + @Override public String getName() { return "GeoCaching.com"; } @@ -153,7 +171,8 @@ public class GCConnector extends AbstractConnector implements ISearchByGeocode, } - public static boolean addToWatchlist(Geocache cache) { + @Override + public boolean addToWatchlist(Geocache cache) { final boolean added = GCParser.addToWatchlist(cache); if (added) { cgData.saveChangedCache(cache); @@ -161,7 +180,8 @@ public class GCConnector extends AbstractConnector implements ISearchByGeocode, return added; } - public static boolean removeFromWatchlist(Geocache cache) { + @Override + public boolean removeFromWatchlist(Geocache cache) { final boolean removed = GCParser.removeFromWatchlist(cache); if (removed) { cgData.saveChangedCache(cache); @@ -244,6 +264,6 @@ public class GCConnector extends AbstractConnector implements ISearchByGeocode, @Override public boolean isActivated() { - return true; + return Settings.isGCConnectorActive(); } } diff --git a/main/src/cgeo/geocaching/connector/gc/GCLoggingManager.java b/main/src/cgeo/geocaching/connector/gc/GCLoggingManager.java new file mode 100644 index 0000000..0fbd718 --- /dev/null +++ b/main/src/cgeo/geocaching/connector/gc/GCLoggingManager.java @@ -0,0 +1,132 @@ +package cgeo.geocaching.connector.gc; + +import cgeo.geocaching.Geocache; +import cgeo.geocaching.R; +import cgeo.geocaching.Settings; +import cgeo.geocaching.TrackableLog; +import cgeo.geocaching.VisitCacheActivity; +import cgeo.geocaching.activity.ActivityMixin; +import cgeo.geocaching.connector.ILoggingManager; +import cgeo.geocaching.connector.ImageResult; +import cgeo.geocaching.connector.LogResult; +import cgeo.geocaching.enumerations.LogType; +import cgeo.geocaching.enumerations.StatusCode; +import cgeo.geocaching.loaders.UrlLoader; +import cgeo.geocaching.network.Parameters; +import cgeo.geocaching.utils.Log; + +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; + +import android.app.Activity; +import android.net.Uri; +import android.os.Bundle; +import android.support.v4.app.LoaderManager; +import android.support.v4.content.Loader; + +import java.util.Calendar; +import java.util.Collections; +import java.util.List; + +public class GCLoggingManager implements ILoggingManager, LoaderManager.LoaderCallbacks<String> { + + private final VisitCacheActivity activity; + private final Geocache cache; + + private String[] viewstates; + private List<TrackableLog> trackables; + private List<LogType> possibleLogTypes; + private boolean hasLoaderError = true; + + public GCLoggingManager(Activity activity, Geocache cache) { + this.activity = (VisitCacheActivity) activity; + this.cache = cache; + } + + @Override + public Loader<String> onCreateLoader(int arg0, Bundle arg1) { + if (!Settings.isLogin()) { // allow offline logging + ActivityMixin.showToast(activity, activity.getResources().getString(R.string.err_login)); + return null; + } + return new UrlLoader(activity.getBaseContext(), "http://www.geocaching.com/seek/log.aspx", new Parameters("ID", cache.getCacheId())); + } + + @Override + public void onLoadFinished(Loader<String> arg0, String page) { + + if (page == null) { + hasLoaderError = true; + } else { + + viewstates = Login.getViewstates(page); + trackables = GCParser.parseTrackableLog(page); + possibleLogTypes = GCParser.parseTypes(page); + + hasLoaderError = possibleLogTypes.isEmpty(); + } + + activity.onLoadFinished(); + } + + @Override + public void onLoaderReset(Loader<String> arg0) { + // nothing to do + } + + @Override + public void init() { + activity.getSupportLoaderManager().initLoader(0, null, this); + } + + @Override + public LogResult postLog(Geocache cache, LogType logType, Calendar date, String log, List<TrackableLog> trackableLogs) { + + try { + final ImmutablePair<StatusCode, String> postResult = GCParser.postLog(cache.getGeocode(), cache.getCacheId(), viewstates, logType, + date.get(Calendar.YEAR), (date.get(Calendar.MONTH) + 1), date.get(Calendar.DATE), + log, trackableLogs); + + return new LogResult(postResult.left, postResult.right); + } catch (Exception e) { + Log.e("GCLoggingManager.postLog", e); + } + + return new LogResult(StatusCode.LOG_POST_ERROR, ""); + } + + @Override + public ImageResult postLogImage(String logId, String imageCaption, String imageDescription, Uri imageUri) { + + if (StringUtils.isNotBlank(imageUri.getPath())) { + + ImmutablePair<StatusCode, String> imageResult = GCParser.uploadLogImage(logId, imageCaption, imageDescription, imageUri); + + return new ImageResult(imageResult.left, imageResult.right); + } + + return new ImageResult(StatusCode.LOGIMAGE_POST_ERROR, ""); + } + + @Override + public boolean hasLoaderError() { + return hasLoaderError; + } + + @Override + public List<TrackableLog> getTrackables() { + if (hasLoaderError) { + return Collections.emptyList(); + } + return trackables; + } + + @Override + public List<LogType> getPossibleLogTypes() { + if (hasLoaderError) { + return Collections.emptyList(); + } + return possibleLogTypes; + } + +} diff --git a/main/src/cgeo/geocaching/connector/oc/AttributeParser.java b/main/src/cgeo/geocaching/connector/oc/AttributeParser.java new file mode 100644 index 0000000..63bee77 --- /dev/null +++ b/main/src/cgeo/geocaching/connector/oc/AttributeParser.java @@ -0,0 +1,327 @@ +// This is a generated file, do not change manually! + +package cgeo.geocaching.connector.oc; + +import java.util.HashMap; +import java.util.Map; + +public class AttributeParser { + + private final static Map<String, Integer> attrMapDe; + private final static Map<String, Integer> attrMapPl; + + static { + attrMapDe = new HashMap<String, Integer>(); + attrMapPl = new HashMap<String, Integer>(); + + // last header line + attrMapDe.put("Listed at Opencaching only", 6); + attrMapDe.put("Dostępna tylko na Opencaching", 6); + attrMapDe.put("Nur bei Opencaching logbar", 6); + attrMapDe.put("Solo loggeable en Opencaching", 6); + attrMapDe.put("Loggabile solo su Opencaching", 6); + attrMapPl.put("Near a Survey Marker", 54); + attrMapPl.put("W pobliżu punktu geodezyjnego", 54); + attrMapPl.put("Whereigo Cache", 55); + attrMapPl.put("Whereigo Cache", 55); + attrMapPl.put("Whereigo Cache", 55); + attrMapDe.put("Letterbox Cache", 8); + attrMapPl.put("Letterbox Cache", 56); + attrMapDe.put("Skrzynka typu Letterbox", 8); + attrMapPl.put("Skrzynka typu Letterbox", 56); + attrMapDe.put("Letterbox (benötigt Stempel)", 8); + attrMapPl.put("Letterbox (benötigt Stempel)", 56); + attrMapDe.put("Letterbox (necesita un estampador)", 8); + attrMapPl.put("Letterbox (necesita un estampador)", 56); + attrMapDe.put("Letterbox (richiede un timbro)", 8); + attrMapPl.put("Letterbox (richiede un timbro)", 56); + attrMapPl.put("GeoHotel", 43); + attrMapPl.put("GeoHotel", 43); + attrMapPl.put("GeoHotel", 43); + attrMapPl.put("Magnetic cache", 49); + attrMapPl.put("Przyczepiona magnesem", 49); + attrMapPl.put("magnetischer Cache", 49); + attrMapPl.put("Description contains an audio file", 50); + attrMapPl.put("Opis zawiera plik audio", 50); + attrMapPl.put("Offset cache", 51); + attrMapPl.put("Offset cache", 51); + attrMapPl.put("Peilungscache", 51); + attrMapPl.put("Garmin's wireless beacon", 52); + attrMapPl.put("Beacon - Garmin Chirp", 52); + attrMapPl.put("Funksignal – Garmin Chirp", 52); + attrMapPl.put("Dead Drop USB cache", 53); + attrMapPl.put("Dead Drop USB skrzynka", 53); + attrMapDe.put("Has a moving target", 31); + attrMapDe.put("bewegliches Ziel", 31); + attrMapDe.put("Objetivo en movimiento", 31); + attrMapDe.put("Oggetto in movimento", 31); + attrMapDe.put("Webcam Cache", 32); + attrMapDe.put("Webcam Cache", 32); + attrMapDe.put("Webcam Cache", 32); + attrMapDe.put("Webcam Cache", 32); + attrMapDe.put("Other cache type", 57); + attrMapDe.put("sonstiger Cachetyp", 57); + attrMapDe.put("Otro tipo de cache", 57); + attrMapDe.put("Altro tipo di cache", 57); + attrMapDe.put("Investigation required", 54); + attrMapDe.put("Recherche", 54); + attrMapDe.put("Investigación", 54); + attrMapDe.put("Ricerca", 54); + attrMapDe.put("Puzzle / Mystery", 55); + attrMapDe.put("Rätsel", 55); + attrMapDe.put("Puzzle / Misterio", 55); + attrMapDe.put("Puzzle / Mystery", 55); + attrMapDe.put("Arithmetical problem", 56); + attrMapDe.put("Rechenaufgabe", 56); + attrMapDe.put("Problema matemático", 56); + attrMapDe.put("Problema matematico", 56); + attrMapDe.put("Ask owner for start conditions", 58); + attrMapDe.put("Startbedingungen beim Owner erfragen", 58); + attrMapDe.put("Ask owner for start conditions", 58); + attrMapDe.put("Ask owner for start conditions", 58); + attrMapPl.put("Wheelchair accessible", 44); + attrMapPl.put("Dostępna dla niepełnosprawnych", 44); + attrMapPl.put("rollstuhltauglich", 44); + attrMapDe.put("Near the parking area", 24); + attrMapDe.put("nahe beim Auto", 24); + attrMapDe.put("Cerca de un Parking", 24); + attrMapDe.put("Vicino all'area di parcheggio", 24); + attrMapPl.put("Access only by walk", 84); + attrMapPl.put("Dostępna tylko pieszo", 84); + attrMapDe.put("Long walk", 25); + attrMapDe.put("längere Wanderung", 25); + attrMapDe.put("Larga caminata", 25); + attrMapDe.put("Lunga camminata", 25); + attrMapDe.put("Swamp, marsh or wading", 26); + attrMapDe.put("sumpfig/matschiges Gelände / waten", 26); + attrMapDe.put("Pantano / terreno fangoso", 26); + attrMapDe.put("Palude o marcita", 26); + attrMapDe.put("Hilly area", 27); + attrMapDe.put("hügeliges Gelände", 27); + attrMapDe.put("Terreno montañoso", 27); + attrMapDe.put("Area collinare", 27); + attrMapDe.put("Some climbing (no gear needed)", 28); + attrMapDe.put("leichtes Klettern (ohne Ausrüstung)", 28); + attrMapDe.put("fácil de subir (sin equipo)", 28); + attrMapDe.put("Arrampicata (attrezzatura non necessaria)", 28); + attrMapDe.put("Swimming required", 29); + attrMapDe.put("Schwimmen erforderlich", 29); + attrMapDe.put("Requiere nadar", 29); + attrMapDe.put("Nuoto necessario", 29); + attrMapDe.put("Access or parking fee", 36); + attrMapDe.put("Zugangs- bzw. Parkentgelt", 36); + attrMapDe.put("Acceso o parking pagando", 36); + attrMapDe.put("Tassa di ingresso o di parcheggio", 36); + attrMapPl.put("Bikes allowed", 85); + attrMapPl.put("Dostępna rowerem", 85); + attrMapPl.put("Hidden in natural surroundings (forests, mountains, etc.)", 60); + attrMapPl.put("Umiejscowiona na łonie natury (lasy, góry, itp.)", 60); + attrMapPl.put("Historic site", 61); + attrMapPl.put("Miejsce historyczne", 61); + attrMapDe.put("Point of interest", 30); + attrMapDe.put("interessanter Ort", 30); + attrMapDe.put("Punto de interes", 30); + attrMapDe.put("Punto di interesse", 30); + attrMapDe.put("Hidden wihin enclosed rooms (caves, buildings etc.)", 33); + attrMapDe.put("in geschlossenen Räumen (Höhle, Gebäude, etc.)", 33); + attrMapDe.put("en espacios confinados (cuevas, edificios, etc)", 33); + attrMapDe.put("All'interno di stanze chiuse (caverne, edifici, ecc.)", 33); + attrMapDe.put("Hidden under water", 34); + attrMapDe.put("Im Wasser versteckt", 34); + attrMapDe.put("En el agua", 34); + attrMapDe.put("Nell'acqua", 34); + attrMapDe.put("Parking area nearby", 18); + attrMapDe.put("Parkplatz in der Nähe", 18); + attrMapDe.put("Parking cercano", 18); + attrMapDe.put("Parcheggio nei pressi", 18); + attrMapDe.put("Public transportation", 19); + attrMapDe.put("erreichbar mit ÖVM", 19); + attrMapDe.put("Transporte Público", 19); + attrMapDe.put("Trasporto pubblico", 19); + attrMapDe.put("Drinking water nearby", 20); + attrMapDe.put("Trinkwasser in der Nähe", 20); + attrMapDe.put("Agua potable en las cercanias", 20); + attrMapDe.put("Acqua potabile nei pressi", 20); + attrMapDe.put("Public restrooms nearby", 21); + attrMapDe.put("öffentliche Toilette in der Nähe", 21); + attrMapDe.put("Aseos públicos cercanos", 21); + attrMapDe.put("Bagni pubblici nei pressi", 21); + attrMapDe.put("Public phone nearby", 22); + attrMapDe.put("Telefon in der Nähe", 22); + attrMapDe.put("Teléfono Público en las cercanias", 22); + attrMapDe.put("Telefono pubblico nei pressi", 22); + attrMapDe.put("First aid available", 23); + attrMapDe.put("Erste Hilfe verfügbar", 23); + attrMapDe.put("Disponible socorro rapido", 23); + attrMapDe.put("Disponibile pronto soccorso", 23); + attrMapDe.put("Available 24/7", 38); + attrMapDe.put("rund um die Uhr machbar", 38); + attrMapDe.put("Disponible las 24 horas", 38); + attrMapDe.put("Disponibile 24 ore", 38); + attrMapDe.put("Not 24/7", 39); + attrMapPl.put("Not 24/7", 80); + attrMapDe.put("Dostępna w określonych godzinach", 39); + attrMapPl.put("Dostępna w określonych godzinach", 80); + attrMapDe.put("nur zu bestimmten Uhrzeiten", 39); + attrMapPl.put("nur zu bestimmten Uhrzeiten", 80); + attrMapDe.put("Sólo disponible a ciertas horas", 39); + attrMapPl.put("Sólo disponible a ciertas horas", 80); + attrMapDe.put("Disponibile solo in certi orari", 39); + attrMapPl.put("Disponibile solo in certi orari", 80); + attrMapDe.put("Not recommended at night", 40); + attrMapDe.put("nur tagüber", 40); + attrMapDe.put("solo por el día", 40); + attrMapDe.put("solo di giorno", 40); + attrMapPl.put("Recommended at night", 91); + attrMapPl.put("Zalecane szukanie nocą", 91); + attrMapPl.put("am besten nachts findbar", 91); + attrMapDe.put("Only at night", 1); + attrMapDe.put("nur bei Nacht", 1); + attrMapDe.put("Sólo por la noche", 1); + attrMapDe.put("Solo di notte", 1); + attrMapDe.put("All seasons", 42); + attrMapDe.put("ganzjähig zugänglich", 42); + attrMapDe.put("Todas las temporadas", 42); + attrMapDe.put("Tutte le stagioni", 42); + attrMapDe.put("Only available during specified seasons", 60); + attrMapDe.put("Nur zu bestimmten Zeiten im Jahr", 60); + attrMapDe.put("Sólo disponible durante las estaciones especificadas", 60); + attrMapDe.put("Disponibile solo in certe stagioni", 60); + attrMapDe.put("Breeding season / protected nature", 43); + attrMapDe.put("Brutsaison / Naturschutz", 43); + attrMapDe.put("Temporada de reproducción / protección de la naturaleza", 43); + attrMapDe.put("Stagione di riproduzione / natura protetta", 43); + attrMapDe.put("Available during winter", 44); + attrMapDe.put("schneesicheres Versteck", 44); + attrMapDe.put("Nieve en el escondite", 44); + attrMapDe.put("Luogo a prova di neve", 44); + attrMapDe.put("Not at high water level", 41); + attrMapDe.put("nicht bei Hochwasser oder Flut", 41); + attrMapDe.put("Compass required", 47); + attrMapPl.put("Compass required", 47); + attrMapDe.put("Potrzebny kompas", 47); + attrMapPl.put("Potrzebny kompas", 47); + attrMapDe.put("Kompass", 47); + attrMapPl.put("Kompass", 47); + attrMapDe.put("Brújula", 47); + attrMapPl.put("Brújula", 47); + attrMapDe.put("Bussola", 47); + attrMapPl.put("Bussola", 47); + attrMapPl.put("Take something to write", 48); + attrMapPl.put("Weź coś do pisania", 48); + attrMapPl.put("You may need a shovel", 81); + attrMapPl.put("Potrzebna łopatka", 81); + attrMapDe.put("Flashlight required", 48); + attrMapPl.put("Flashlight required", 82); + attrMapDe.put("Potrzebna latarka", 48); + attrMapPl.put("Potrzebna latarka", 82); + attrMapDe.put("Taschenlampe", 48); + attrMapPl.put("Taschenlampe", 82); + attrMapDe.put("Linterna", 48); + attrMapPl.put("Linterna", 82); + attrMapDe.put("Lampada tascabile", 48); + attrMapPl.put("Lampada tascabile", 82); + attrMapDe.put("Climbing gear required", 49); + attrMapDe.put("Kletterzeug", 49); + attrMapDe.put("Equipo de escalada", 49); + attrMapDe.put("Attrezzatura per arrampicata", 49); + attrMapDe.put("Cave equipment required", 50); + attrMapDe.put("Höhlenzeug", 50); + attrMapDe.put("Equipación para cuevas", 50); + attrMapDe.put("Attrezzatura per grotta", 50); + attrMapDe.put("Diving equipment required", 51); + attrMapDe.put("Taucherausrüstung", 51); + attrMapDe.put("Diving equipment", 51); + attrMapDe.put("Equipo de buceo", 51); + attrMapDe.put("Special tools required", 46); + attrMapPl.put("Special tools required", 83); + attrMapDe.put("Wymagany dodatkowy sprzęt", 46); + attrMapPl.put("Wymagany dodatkowy sprzęt", 83); + attrMapDe.put("spezielle Ausrüstung", 46); + attrMapPl.put("spezielle Ausrüstung", 83); + attrMapDe.put("Equipamiento especial", 46); + attrMapPl.put("Equipamiento especial", 83); + attrMapDe.put("Equipaggiamento speciale", 46); + attrMapPl.put("Equipaggiamento speciale", 83); + attrMapDe.put("Requires a boat", 52); + attrMapPl.put("Requires a boat", 86); + attrMapDe.put("Wymaga sprzętu pływającego", 52); + attrMapPl.put("Wymaga sprzętu pływającego", 86); + attrMapDe.put("Wasserfahrzeug", 52); + attrMapPl.put("Wasserfahrzeug", 86); + attrMapDe.put("Barca", 52); + attrMapPl.put("Barca", 86); + attrMapDe.put("Barca", 52); + attrMapPl.put("Barca", 86); + attrMapDe.put("No GPS required", 35); + attrMapDe.put("ohne GPS findbar", 35); + attrMapDe.put("Sin GPS", 35); + attrMapDe.put("Senza GPS", 35); + attrMapDe.put("Dangerous area", 9); + attrMapPl.put("Dangerous area", 90); + attrMapDe.put("Skrzynka niebezpieczna", 9); + attrMapPl.put("Skrzynka niebezpieczna", 90); + attrMapDe.put("gefährliches Gebiet", 9); + attrMapPl.put("gefährliches Gebiet", 90); + attrMapDe.put("Zona Peligrosa", 9); + attrMapPl.put("Zona Peligrosa", 90); + attrMapDe.put("Area pericolosa", 9); + attrMapPl.put("Area pericolosa", 90); + attrMapDe.put("Active railway nearby", 10); + attrMapDe.put("aktive Eisenbahnlinie in der Nähe", 10); + attrMapDe.put("Cerca del ferrocarril activo", 10); + attrMapDe.put("Ferrovia attiva nei pressi", 10); + attrMapDe.put("Cliff / Rocks", 11); + attrMapDe.put("Klippen / Felsen", 11); + attrMapDe.put("Acantilado / Rocas", 11); + attrMapDe.put("Scogliera / Rocce", 11); + attrMapDe.put("Hunting", 12); + attrMapDe.put("Jagdgebiet", 12); + attrMapDe.put("Zona de Caza", 12); + attrMapDe.put("Caccia", 12); + attrMapDe.put("Thorns", 13); + attrMapDe.put("Dornen", 13); + attrMapDe.put("Espinas", 13); + attrMapDe.put("Spine", 13); + attrMapDe.put("Ticks", 14); + attrMapDe.put("Zecken", 14); + attrMapDe.put("Garrapatas", 14); + attrMapDe.put("Zecche", 14); + attrMapDe.put("Abandoned mines", 15); + attrMapDe.put("Folgen des Bergbaus", 15); + attrMapDe.put("Mina abandonada", 15); + attrMapDe.put("Miniere abbandonate", 15); + attrMapDe.put("Poisonous plants", 16); + attrMapDe.put("giftige Pflanzen", 16); + attrMapDe.put("Planta venenosa", 16); + attrMapDe.put("Piante velenose", 16); + attrMapDe.put("Dangerous animals", 17); + attrMapDe.put("giftige/gefährliche Tiere", 17); + attrMapDe.put("Animales Peligrosos", 17); + attrMapDe.put("Animali pericolosi", 17); + attrMapPl.put("Quick cache", 40); + attrMapPl.put("Szybka skrzynka", 40); + attrMapDe.put("Overnight stay necessary", 37); + attrMapDe.put("Übernachtung erforderlich", 37); + attrMapDe.put("Necesario pernoctar", 37); + attrMapDe.put("Necessario pernottamento", 37); + attrMapPl.put("Take your children", 41); + attrMapPl.put("Można zabrać dzieci", 41); + attrMapDe.put("Suited for children (10-12 yo)", 59); + attrMapDe.put("kindgerecht (10-12 Jahre)", 59); + attrMapDe.put("Apto para niños (10-12 años)", 59); + attrMapDe.put("Suited for children (10-12 anni)", 59); + // first trailer line + + } + + public static int getOcDeId(final String name) { + + int result = 0; + + if (attrMapDe.containsKey(name)) { + result = attrMapDe.get(name); + } + return result; + } +} diff --git a/main/src/cgeo/geocaching/connector/oc/OC11XMLParser.java b/main/src/cgeo/geocaching/connector/oc/OC11XMLParser.java deleted file mode 100644 index d03062f..0000000 --- a/main/src/cgeo/geocaching/connector/oc/OC11XMLParser.java +++ /dev/null @@ -1,762 +0,0 @@ -package cgeo.geocaching.connector.oc; - -import cgeo.geocaching.Geocache; -import cgeo.geocaching.Image; -import cgeo.geocaching.LogEntry; -import cgeo.geocaching.R; -import cgeo.geocaching.Settings; -import cgeo.geocaching.cgeoapplication; -import cgeo.geocaching.connector.ConnectorFactory; -import cgeo.geocaching.connector.IConnector; -import cgeo.geocaching.connector.gc.GCConnector; -import cgeo.geocaching.enumerations.CacheAttribute; -import cgeo.geocaching.enumerations.CacheSize; -import cgeo.geocaching.enumerations.CacheType; -import cgeo.geocaching.enumerations.LogType; -import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.utils.Log; - -import org.apache.commons.lang3.StringUtils; -import org.xml.sax.Attributes; -import org.xml.sax.SAXException; - -import android.content.res.Resources; -import android.sax.Element; -import android.sax.EndElementListener; -import android.sax.EndTextElementListener; -import android.sax.RootElement; -import android.sax.StartElementListener; -import android.util.Xml; - -import java.io.IOException; -import java.io.InputStream; -import java.text.ParseException; -import java.text.SimpleDateFormat; -import java.util.Collection; -import java.util.Date; -import java.util.HashMap; -import java.util.Locale; -import java.util.Map; -import java.util.TimeZone; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -public class OC11XMLParser { - - private static final String[] MARKUP = new String[] { "p", "span" }; - private static Pattern STRIP_DATE = Pattern.compile("\\+0([0-9]){1}\\:00"); - private static Pattern LOCAL_URL = Pattern.compile("href=\"(.*)\""); - private static final int CACHE_PARSE_LIMIT = 250; - private static final Resources res = cgeoapplication.getInstance().getResources(); - private static final Pattern WHITESPACE = Pattern.compile("<p>(\\s| )*</p>"); - - - private static ImageHolder imageHolder = null; - - private static class CacheHolder { - public Geocache cache; - public String latitude; - public String longitude; - } - - private static class CacheLog { - public String id; - public String cacheId; - public LogEntry logEntry; - } - - private static class CacheDescription { - public String cacheId; - public String shortDesc; - public String desc; - public String hint; - } - - private static class ImageHolder { - public String url; - public String objectId; - protected String title; - protected boolean isSpoiler = false; - } - - private static Date parseFullDate(final String date) { - final SimpleDateFormat ISO8601DATEFORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US); - ISO8601DATEFORMAT.setTimeZone(TimeZone.getTimeZone("UTC")); - final String strippedDate = STRIP_DATE.matcher(date).replaceAll("+0$100"); - try { - return ISO8601DATEFORMAT.parse(strippedDate); - } catch (ParseException e) { - Log.e("OC11XMLParser.parseFullDate", e); - } - return null; - } - - private static Date parseDayDate(final String date) { - final SimpleDateFormat ISO8601DATEFORMAT = new SimpleDateFormat("yyyy-MM-dd", Locale.US); - ISO8601DATEFORMAT.setTimeZone(TimeZone.getTimeZone("UTC")); - final String strippedDate = STRIP_DATE.matcher(date).replaceAll("+0$100"); - try { - return ISO8601DATEFORMAT.parse(strippedDate); - } catch (ParseException e) { - Log.e("OC11XMLParser.parseDayDate", e); - } - return null; - } - - private static CacheSize getCacheSize(final String sizeId) { - try { - int size = Integer.parseInt(sizeId); - - switch (size) { - case 1: - return CacheSize.OTHER; - case 2: - return CacheSize.MICRO; - case 3: - return CacheSize.SMALL; - case 4: - return CacheSize.REGULAR; - case 5: - case 6: - return CacheSize.LARGE; - case 8: - return CacheSize.VIRTUAL; - default: - break; - } - } catch (NumberFormatException e) { - Log.e("OC11XMLParser.getCacheSize", e); - } - return CacheSize.NOT_CHOSEN; - } - - private static CacheType getCacheType(final String typeId) { - try { - int type = Integer.parseInt(typeId); - switch (type) { - case 1: // Other/unbekannter Cachetyp - return CacheType.UNKNOWN; - case 2: // Trad./normaler Cache - return CacheType.TRADITIONAL; - case 3: // Multi/Multicache - return CacheType.MULTI; - case 4: // Virt./virtueller Cache - return CacheType.VIRTUAL; - case 5: // ICam./Webcam-Cache - return CacheType.WEBCAM; - case 6: // Event/Event-Cache - return CacheType.EVENT; - case 7: // Quiz/Rätselcache - return CacheType.MYSTERY; - case 8: // Math/Mathe-/Physikcache - return CacheType.MYSTERY; - case 9: // Moving/beweglicher Cache - return CacheType.VIRTUAL; - case 10: // Driv./Drive-In - return CacheType.TRADITIONAL; - default: - return CacheType.UNKNOWN; - } - } catch (NumberFormatException e) { - Log.e("OC11XMLParser.getCacheType", e); - } - return CacheType.UNKNOWN; - } - - private static LogType getLogType(final int typeId) { - switch (typeId) { - case 1: - return LogType.FOUND_IT; - case 2: - return LogType.DIDNT_FIND_IT; - case 3: - return LogType.NOTE; - case 7: - return LogType.ATTENDED; - case 8: - return LogType.WILL_ATTEND; - default: - return LogType.UNKNOWN; - } - } - - private static void setCacheStatus(final int statusId, final Geocache cache) { - switch (statusId) { - case 1: - cache.setArchived(false); - cache.setDisabled(false); - break; - case 2: - cache.setArchived(false); - cache.setDisabled(true); - break; - default: - cache.setArchived(true); - cache.setDisabled(false); - break; - } - } - - private static void resetCache(final CacheHolder cacheHolder) { - cacheHolder.cache = new Geocache(null); - cacheHolder.cache.setReliableLatLon(true); - cacheHolder.cache.setDescription(StringUtils.EMPTY); - cacheHolder.latitude = "0.0"; - cacheHolder.longitude = "0.0"; - } - - private static void resetLog(final CacheLog log) { - log.cacheId = StringUtils.EMPTY; - log.logEntry = new LogEntry("", 0, LogType.UNKNOWN, ""); - } - - private static void resetDesc(final CacheDescription desc) { - desc.cacheId = StringUtils.EMPTY; - desc.shortDesc = StringUtils.EMPTY; - desc.desc = StringUtils.EMPTY; - desc.hint = StringUtils.EMPTY; - } - - private static int attributeId; - - public static Collection<Geocache> parseCaches(final InputStream stream) throws IOException { - // parse and return caches without filtering - return parseCaches(stream, true); - } - - public static Collection<Geocache> parseCachesFiltered(final InputStream stream) throws IOException { - // parse caches and filter result - return parseCaches(stream, false); - } - - private static Collection<Geocache> parseCaches(final InputStream stream, boolean ignoreFiltersIn) throws IOException { - - final Map<String, Geocache> caches = new HashMap<String, Geocache>(); - final Map<String, LogEntry> logs = new HashMap<String, LogEntry>(); - - final CacheHolder cacheHolder = new CacheHolder(); - final CacheLog logHolder = new CacheLog(); - final CacheDescription descHolder = new CacheDescription(); - - final RootElement root = new RootElement("oc11xml"); - final Element cacheNode = root.getChild("cache"); - - final boolean ignoreFilters = ignoreFiltersIn; - - // cache - cacheNode.setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attributes) { - resetCache(cacheHolder); - } - - }); - - cacheNode.setEndElementListener(new EndElementListener() { - - @Override - public void end() { - Geocache cache = cacheHolder.cache; - Geopoint coords = new Geopoint(cacheHolder.latitude, cacheHolder.longitude); - cache.setCoords(coords); - if (caches.size() < CACHE_PARSE_LIMIT && isValid(cache) && (ignoreFilters || !isExcluded(cache))) { - cache.setDetailedUpdatedNow(); - caches.put(cache.getCacheId(), cache); - } - } - - private boolean isExcluded(Geocache cache) { - if (cache.isArchived()) { - return true; - } - if (cache.isDisabled() && Settings.isExcludeDisabledCaches()) { - return true; - } - if ((cache.isFound() || cache.isOwner()) && Settings.isExcludeMyCaches()) { - return true; - } - return !Settings.getCacheType().contains(cache); - } - - private boolean isValid(Geocache cache) { - return StringUtils.isNotBlank(cache.getGeocode()) && !cache.getCoords().equals(Geopoint.ZERO); - } - }); - - // cache.id - cacheNode.getChild("id").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - cacheHolder.cache.setCacheId(body); - } - }); - - // cache.longitude - cacheNode.getChild("longitude").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - String longitude = body.trim(); - if (StringUtils.isNotBlank(longitude)) { - cacheHolder.longitude = longitude; - } - } - }); - - // cache.latitude - cacheNode.getChild("latitude").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - String latitude = body.trim(); - if (StringUtils.isNotBlank(latitude)) { - cacheHolder.latitude = latitude; - } - } - }); - - // cache.name - cacheNode.getChild("name").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - final String content = body.trim(); - cacheHolder.cache.setName(content); - } - }); - - // cache.waypoints[oc] - cacheNode.getChild("waypoints").setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attrs) { - if (attrs.getIndex("oc") > -1) { - cacheHolder.cache.setGeocode(attrs.getValue("oc")); - } - if (attrs.getIndex("gccom") > -1) { - String gccode = attrs.getValue("gccom"); - if (!StringUtils.isBlank(gccode)) { - cacheHolder.cache.setDescription(res.getString(R.string.cache_listed_on, GCConnector.getInstance().getName()) + ": <a href=\"http://coord.info/" + gccode + "\">" + gccode + "</a><br /><br />"); - } - } - } - }); - - // cache.type[id] - cacheNode.getChild("type").setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attrs) { - if (attrs.getIndex("id") > -1) { - final String typeId = attrs.getValue("id"); - cacheHolder.cache.setType(getCacheType(typeId)); - } - } - }); - - // cache.status[id] - cacheNode.getChild("status").setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attrs) { - if (attrs.getIndex("id") > -1) { - try { - final int statusId = Integer.parseInt(attrs.getValue("id")); - setCacheStatus(statusId, cacheHolder.cache); - } catch (NumberFormatException e) { - Log.w(String.format("Failed to parse status of cache '%s'.", cacheHolder.cache.getGeocode())); - } - } - } - }); - - // cache.size[id] - cacheNode.getChild("size").setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attrs) { - if (attrs.getIndex("id") > -1) { - final String typeId = attrs.getValue("id"); - cacheHolder.cache.setSize(getCacheSize(typeId)); - } - } - }); - - // cache.difficulty - cacheNode.getChild("difficulty").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - final String content = body.trim(); - try { - cacheHolder.cache.setDifficulty(Float.valueOf(content)); - } catch (NumberFormatException e) { - Log.e("OC11XMLParser: unknown difficulty " + content, e); - } - } - }); - - // cache.terrain - cacheNode.getChild("terrain").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - final String content = body.trim(); - try { - cacheHolder.cache.setTerrain(Float.valueOf(content)); - } catch (NumberFormatException e) { - Log.e("OC11XMLParser: unknown terrain " + content, e); - } - } - }); - - // cache.datehidden - cacheNode.getChild("datehidden").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - final String content = body.trim(); - cacheHolder.cache.setHidden(parseFullDate(content)); - } - }); - - // cache.userid - final Element useridNode = cacheNode.getChild("userid"); - - useridNode.setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attributes) { - if (attributes.getIndex("id") > -1) { - cacheHolder.cache.setOwnerUserId(attributes.getValue("id")); - } - } - }); - - useridNode.setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - cacheHolder.cache.setOwnerDisplayName(body); - } - }); - - // cache.attributes.attribute - final Element attributeNode = cacheNode.getChild("attributes").getChild("attribute"); - - attributeNode.setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attributes) { - if (attributes.getIndex("id") > -1) { - try { - attributeId = Integer.parseInt(attributes.getValue("id")); - } catch (NumberFormatException e) { - Log.w(String.format("Failed to parse attribute id of cache '%s'.", cacheHolder.cache.getGeocode())); - } - } - } - }); - - attributeNode.setEndTextElementListener(new EndTextElementListener() { - @Override - public void end(String body) { - CacheAttribute attribute = CacheAttribute.getByOcId(attributeId); - if (attribute != null) { - // semantic of attributes on opencaching is always "yes" - cacheHolder.cache.getAttributes().add(attribute.getAttributeName(true)); - } - else { - if (StringUtils.isNotBlank(body)) { - cacheHolder.cache.getAttributes().add(body.trim()); - } - } - } - }); - - // cachedesc - final Element cacheDesc = root.getChild("cachedesc"); - - cacheDesc.setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attributes) { - resetDesc(descHolder); - } - }); - - cacheDesc.setEndElementListener(new EndElementListener() { - - @Override - public void end() { - final Geocache cache = caches.get(descHolder.cacheId); - if (cache != null) { - cache.setShortDescription(descHolder.shortDesc); - cache.setDescription(cache.getDescription() + descHolder.desc); - cache.setHint(descHolder.hint); - } - } - }); - - // cachedesc.cacheid - cacheDesc.getChild("cacheid").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - descHolder.cacheId = body; - } - }); - - // cachedesc.desc - cacheDesc.getChild("shortdesc").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - final String content = body.trim(); - descHolder.shortDesc = linkify(stripEmptyText(content)); - } - }); - - // cachedesc.desc - cacheDesc.getChild("desc").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - final String content = body.trim(); - descHolder.desc = linkify(stripEmptyText(content)); - } - }); - - // cachedesc.hint - cacheDesc.getChild("hint").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - descHolder.hint = body.trim(); - } - }); - - // cachelog - final Element cacheLog = root.getChild("cachelog"); - - cacheLog.setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attrs) { - resetLog(logHolder); - } - }); - - cacheLog.setEndElementListener(new EndElementListener() { - - @Override - public void end() { - final Geocache cache = caches.get(logHolder.cacheId); - if (cache != null && logHolder.logEntry.type != LogType.UNKNOWN) { - logs.put(logHolder.id, logHolder.logEntry); - cache.getLogs().add(0, logHolder.logEntry); - if ((logHolder.logEntry.type == LogType.FOUND_IT || logHolder.logEntry.type == LogType.ATTENDED) - && StringUtils.equalsIgnoreCase(logHolder.logEntry.author, Settings.getOCConnectorUserName())) { - cache.setFound(true); - cache.setVisitedDate(logHolder.logEntry.date); - } - } - } - }); - - // cachelog.id - cacheLog.getChild("id").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - logHolder.id = StringUtils.trim(body); - } - }); - - // cachelog.cacheid - cacheLog.getChild("cacheid").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - logHolder.cacheId = body; - } - }); - - // cachelog.date - cacheLog.getChild("date").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - try { - logHolder.logEntry.date = parseDayDate(body).getTime(); - } catch (NullPointerException e) { - Log.w("Failed to parse log date", e); - } - } - }); - - // cachelog.logtype - cacheLog.getChild("logtype").setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attrs) { - if (attrs.getIndex("id") > -1) { - final String id = attrs.getValue("id"); - try { - final int typeId = Integer.parseInt(id); - logHolder.logEntry.type = getLogType(typeId); - } catch (NumberFormatException e) { - Log.e("OC11XMLParser, unknown logtype " + id, e); - } - } - } - }); - - // cachelog.userid - cacheLog.getChild("userid").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String finderName) { - logHolder.logEntry.author = finderName; - } - }); - - // cachelog.text - cacheLog.getChild("text").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String logText) { - logHolder.logEntry.log = stripEmptyText(logText); - } - }); - - // pictures - final Element picture = root.getChild("picture"); - - picture.setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attrs) { - imageHolder = new ImageHolder(); - } - }); - - picture.setEndElementListener(new EndElementListener() { - - @Override - public void end() { - if (imageHolder.isSpoiler) { - final Geocache cache = caches.get(imageHolder.objectId); - if (cache != null) { - Image spoiler = new Image(imageHolder.url, imageHolder.title); - cache.addSpoiler(spoiler); - } - } - else { - final LogEntry log = logs.get(imageHolder.objectId); - if (log != null) { - log.addLogImage(new Image(imageHolder.url, imageHolder.title)); - } - } - } - }); - - // picture.object - picture.getChild("object").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - imageHolder.objectId = StringUtils.trim(body); - } - }); - - // picture.title - picture.getChild("title").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - imageHolder.title = StringUtils.trim(body); - } - }); - - // picture.url - picture.getChild("url").setEndTextElementListener(new EndTextElementListener() { - - @Override - public void end(String body) { - imageHolder.url = StringUtils.trim(body); - } - }); - - // picture.attributes - picture.getChild("attributes").setStartElementListener(new StartElementListener() { - - @Override - public void start(Attributes attributes) { - if (attributes.getIndex("spoiler") > -1) { - String spoiler = attributes.getValue("spoiler"); - imageHolder.isSpoiler = ("1".equals(spoiler)); - } - } - }); - - try { - Xml.parse(stream, Xml.Encoding.UTF_8, root.getContentHandler()); - return caches.values(); - } catch (SAXException e) { - Log.e("Cannot parse .gpx file as oc11xml: could not parse XML", e); - return null; - } - } - - /** - * Converts local links to absolute links targeting the OC website. - */ - private static String linkify(String input) { - String result = input; - Matcher matcher = LOCAL_URL.matcher(result); - while (matcher.find()) { - String url = matcher.group(1); - if (!url.contains(":/")) { - IConnector ocConnector = ConnectorFactory.getConnector("OCXXX"); - String prefix = "http://" + ocConnector.getHost() + "/"; - result = StringUtils.replace(result, url, prefix + url); - matcher = LOCAL_URL.matcher(result); - } - } - return result; - } - - /** - * Removes some unneeded markup and whitespace. Log texts are typically encapsulated in paragraph tags which lead to - * more empty space on rendering. - */ - protected static String stripEmptyText(String input) { - final Matcher matcher = WHITESPACE.matcher(input); - String result = matcher.replaceAll("").trim(); - if (!StringUtils.startsWith(result, "<")) { - return result; - } - return stripMarkup(result); - } - - private static String stripMarkup(final String input) { - String result = input; - for (String tagName : MARKUP) { - final String startTag = "<" + tagName + ">"; - if (StringUtils.startsWith(result, startTag)) { - final String endTag = "</" + tagName + ">"; - if (StringUtils.endsWith(result, endTag)) { - String inner = result.substring(startTag.length(), result.length() - endTag.length()).trim(); - String nested = stripMarkup(inner); - if (!nested.contains(startTag)) { - result = nested; - } - } - } - } - return result; - } -}
\ No newline at end of file diff --git a/main/src/cgeo/geocaching/connector/oc/OCApiConnector.java b/main/src/cgeo/geocaching/connector/oc/OCApiConnector.java index 69cf8a4..3780c4d 100644 --- a/main/src/cgeo/geocaching/connector/oc/OCApiConnector.java +++ b/main/src/cgeo/geocaching/connector/oc/OCApiConnector.java @@ -23,7 +23,7 @@ public class OCApiConnector extends OCConnector implements ISearchByGeocode { @Override public String getLicenseText(final Geocache cache) { // NOT TO BE TRANSLATED - return "<a href=\"" + getCacheUrl(cache) + "\">" + getName() + "</a> data licensed under the Creative Commons BY-SA 3.0 License"; + return "© " + cache.getOwnerDisplayName() + ", <a href=\"" + getCacheUrl(cache) + "\">" + getName() + "</a>, CC-BY-NC-ND, alle Logeinträge © jeweiliger Autor"; } @Override @@ -40,4 +40,8 @@ public class OCApiConnector extends OCConnector implements ISearchByGeocode { // currently always active, but only for details download return true; } + + public String getCK() { + return CryptUtils.rot13(cK); + } } diff --git a/main/src/cgeo/geocaching/connector/oc/OCApiLiveConnector.java b/main/src/cgeo/geocaching/connector/oc/OCApiLiveConnector.java new file mode 100644 index 0000000..4e57831 --- /dev/null +++ b/main/src/cgeo/geocaching/connector/oc/OCApiLiveConnector.java @@ -0,0 +1,82 @@ +package cgeo.geocaching.connector.oc; + +import cgeo.geocaching.Geocache; +import cgeo.geocaching.SearchResult; +import cgeo.geocaching.cgData; +import cgeo.geocaching.cgeoapplication; +import cgeo.geocaching.connector.ILoggingManager; +import cgeo.geocaching.connector.capability.ISearchByCenter; +import cgeo.geocaching.connector.capability.ISearchByViewPort; +import cgeo.geocaching.geopoint.Geopoint; +import cgeo.geocaching.geopoint.Viewport; +import cgeo.geocaching.utils.CryptUtils; + +import android.app.Activity; + +public class OCApiLiveConnector extends OCApiConnector implements ISearchByCenter, ISearchByViewPort { + + private String cS; + + public OCApiLiveConnector(String name, String host, String prefix, int cKResId, int cSResId) { + super(name, host, prefix, CryptUtils.rot13(cgeoapplication.getInstance().getResources().getString(cKResId))); + + cS = CryptUtils.rot13(cgeoapplication.getInstance().getResources().getString(cSResId)); + } + + @Override + public SearchResult searchByViewport(Viewport viewport, String[] tokens) { + return new SearchResult(OkapiClient.getCachesBBox(viewport, this)); + } + + @Override + public SearchResult searchByCenter(Geopoint center) { + + return new SearchResult(OkapiClient.getCachesAround(center, this)); + } + + public String getCS() { + return CryptUtils.rot13(cS); + } + + @Override + public boolean supportsWatchList() { + return true; + } + + @Override + public boolean addToWatchlist(Geocache cache) { + final boolean added = OkapiClient.setWatchState(cache, true, this); + + if (added) { + cgData.saveChangedCache(cache); + } + + return added; + } + + @Override + public boolean removeFromWatchlist(Geocache cache) { + final boolean removed = OkapiClient.setWatchState(cache, false, this); + + if (removed) { + cgData.saveChangedCache(cache); + } + + return removed; + } + + @Override + public boolean supportsLogging() { + return true; + } + + @Override + public ILoggingManager getLoggingManager(Activity activity, Geocache cache) { + return new OkapiLoggingManager(activity, this, cache); + } + + @Override + public boolean canLog(Geocache cache) { + return true; + } +} diff --git a/main/src/cgeo/geocaching/connector/oc/OCAuthorizationActivity.java b/main/src/cgeo/geocaching/connector/oc/OCAuthorizationActivity.java new file mode 100644 index 0000000..779c1c5 --- /dev/null +++ b/main/src/cgeo/geocaching/connector/oc/OCAuthorizationActivity.java @@ -0,0 +1,109 @@ +package cgeo.geocaching.connector.oc; + +import cgeo.geocaching.R; +import cgeo.geocaching.Settings; +import cgeo.geocaching.cgeoapplication; +import cgeo.geocaching.network.OAuthAuthorizationActivity; + +import org.apache.commons.lang3.tuple.ImmutablePair; + +public class OCAuthorizationActivity extends OAuthAuthorizationActivity { + + private final int siteResId = R.string.auth_ocde; + + public OCAuthorizationActivity() { + super("www.opencaching.de", + "/okapi/services/oauth/request_token", + "/okapi/services/oauth/authorize", + "/okapi/services/oauth/access_token", + false, + cgeoapplication.getInstance().getResources().getString(R.string.oc_de_okapi_consumer_key), + cgeoapplication.getInstance().getResources().getString(R.string.oc_de_okapi_consumer_secret)); + } + + @Override + protected ImmutablePair<String, String> getTempToken() { + return Settings.getTempOCDEToken(); + } + + @Override + protected void setTempTokens(String tokenPublic, String tokenSecret) { + Settings.setOCDETempTokens(tokenPublic, tokenSecret); + } + + @Override + protected void setTokens(String tokenPublic, String tokenSecret, boolean enable) { + Settings.setOCDETokens(tokenPublic, tokenSecret, enable); + } + + @Override + protected String getAuthTitle() { + return res.getString(siteResId); + } + + @Override + protected String getAuthAgain() { + return res.getString(R.string.auth_again_oc); + } + + @Override + protected String getErrAuthInitialize() { + return res.getString(R.string.err_auth_initialize); + } + + @Override + protected String getAuthStart() { + return res.getString(R.string.auth_start_oc); + } + + @Override + protected String getAuthDialogCompleted() { + return res.getString(R.string.auth_dialog_completed_oc, getAuthTitle()); + } + + @Override + protected String getErrAuthProcess() { + return res.getString(R.string.err_auth_process); + } + + @Override + protected String getAuthDialogWait() { + return res.getString(R.string.auth_dialog_wait_oc, getAuthTitle()); + } + + @Override + protected String getAuthDialogPinTitle() { + return res.getString(R.string.auth_dialog_pin_title_oc); + } + + @Override + protected String getAuthDialogPinMessage() { + return res.getString(R.string.auth_dialog_pin_message_oc, getAuthTitle()); + } + + @Override + protected String getAboutAuth1() { + return res.getString(R.string.about_auth_1_oc, getAuthTitle()); + } + + @Override + protected String getAboutAuth2() { + return res.getString(R.string.about_auth_2_oc, getAuthTitle(), getAuthTitle()); + } + + @Override + protected String getAuthAuthorize() { + return res.getString(R.string.auth_authorize_oc); + } + + @Override + protected String getAuthPinHint() { + return res.getString(R.string.auth_pin_hint_oc, getAuthTitle()); + } + + @Override + protected String getAuthFinish() { + return res.getString(R.string.auth_finish_oc); + } + +} diff --git a/main/src/cgeo/geocaching/connector/oc/OCXMLApiConnector.java b/main/src/cgeo/geocaching/connector/oc/OCXMLApiConnector.java deleted file mode 100644 index 43fdcfc..0000000 --- a/main/src/cgeo/geocaching/connector/oc/OCXMLApiConnector.java +++ /dev/null @@ -1,67 +0,0 @@ -package cgeo.geocaching.connector.oc; - -import cgeo.geocaching.Geocache; -import cgeo.geocaching.ICache; -import cgeo.geocaching.SearchResult; -import cgeo.geocaching.Settings; -import cgeo.geocaching.connector.capability.ISearchByCenter; -import cgeo.geocaching.connector.capability.ISearchByGeocode; -import cgeo.geocaching.connector.capability.ISearchByViewPort; -import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.geopoint.Viewport; -import cgeo.geocaching.ui.Formatter; -import cgeo.geocaching.utils.CancellableHandler; - -import org.apache.commons.lang3.StringUtils; - -public class OCXMLApiConnector extends OCConnector implements ISearchByGeocode, ISearchByCenter, ISearchByViewPort { - - private final static double SEARCH_DISTANCE_LIMIT = 15.0; - private final static double NEARBY_SEARCH_DISTANCE = 5.0; - - public OCXMLApiConnector(String name, String host, String prefix) { - super(name, host, prefix); - } - - @Override - public SearchResult searchByGeocode(final String geocode, final String guid, CancellableHandler handler) { - final Geocache cache = OCXMLClient.getCache(geocode); - if (cache == null) { - return null; - } - return new SearchResult(cache); - } - - @Override - public SearchResult searchByCenter(final Geopoint center) { - return new SearchResult(OCXMLClient.getCachesAround(center, NEARBY_SEARCH_DISTANCE)); - } - - @Override - public SearchResult searchByViewport(final Viewport viewport, final String[] tokens) { - final Geopoint center = viewport.getCenter(); - double distance = center.distanceTo(viewport.bottomLeft) * 1.15; - if (distance > SEARCH_DISTANCE_LIMIT) { - distance = SEARCH_DISTANCE_LIMIT; - } - return new SearchResult(OCXMLClient.getCachesAround(center, distance)); - } - - @Override - public boolean isActivated() { - // currently only tested and working with oc.de - return Settings.isOCConnectorActive(); - } - - @Override - public boolean isOwner(ICache cache) { - return StringUtils.equalsIgnoreCase(cache.getOwnerDisplayName(), Settings.getOCConnectorUserName()); - } - - @Override - public String getLicenseText(Geocache cache) { - // not to be translated - return "© " + cache.getOwnerDisplayName() + ", " + "<a href=\"" + getCacheUrl(cache) + "\">www.opencaching.de</a>, CC-BY-NC-ND, Stand: " + Formatter.formatFullDate(cache.getUpdated()); - } - -} diff --git a/main/src/cgeo/geocaching/connector/oc/OCXMLClient.java b/main/src/cgeo/geocaching/connector/oc/OCXMLClient.java deleted file mode 100644 index df75682..0000000 --- a/main/src/cgeo/geocaching/connector/oc/OCXMLClient.java +++ /dev/null @@ -1,122 +0,0 @@ -package cgeo.geocaching.connector.oc; - -import cgeo.geocaching.Geocache; -import cgeo.geocaching.cgData; -import cgeo.geocaching.connector.ConnectorFactory; -import cgeo.geocaching.connector.IConnector; -import cgeo.geocaching.enumerations.LoadFlags; -import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.geopoint.GeopointFormatter; -import cgeo.geocaching.network.Network; -import cgeo.geocaching.network.Parameters; -import cgeo.geocaching.utils.IOUtils; -import cgeo.geocaching.utils.Log; - -import ch.boye.httpclientandroidlib.HttpResponse; - -import org.apache.commons.lang3.StringUtils; - -import java.io.BufferedInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.util.Collection; -import java.util.Collections; -import java.util.Locale; -import java.util.zip.GZIPInputStream; - -public class OCXMLClient { - - private static final String SERVICE_CACHE = "/xml/ocxml11.php"; - - // Url for single cache requests - // http://www.opencaching.de/xml/ocxml11.php?modifiedsince=20060320000000&user=0&cache=1&cachedesc=1&cachelog=1&picture=1&removedobject=0&session=0&doctype=0&charset=utf-8&wp=OCC9BE - - public static Geocache getCache(final String geoCode) { - try { - final Parameters params = getOCXmlQueryParameters(true, true, true); - params.put("wp", geoCode); - final InputStream data = request(ConnectorFactory.getConnector(geoCode), SERVICE_CACHE, params); - - if (data == null) { - return null; - } - - final BufferedInputStream stream = new BufferedInputStream(new GZIPInputStream(data)); - Collection<Geocache> caches = OC11XMLParser.parseCaches(stream); - if (caches.iterator().hasNext()) { - Geocache cache = caches.iterator().next(); - cgData.saveCache(cache, LoadFlags.SAVE_ALL); - IOUtils.closeQuietly(stream); - return cache; - } - return null; - } catch (IOException e) { - Log.e("Error parsing cache '" + geoCode + "'", e); - return null; - } - } - - public static Collection<Geocache> getCachesAround(final Geopoint center, final double distance) { - try { - final Parameters params = getOCXmlQueryParameters(false, false, false); - params.put("lat", GeopointFormatter.format(GeopointFormatter.Format.LAT_DECDEGREE_RAW, center)); - params.put("lon", GeopointFormatter.format(GeopointFormatter.Format.LON_DECDEGREE_RAW, center)); - params.put("distance", String.format(Locale.US, "%f", distance)); - final InputStream data = request(ConnectorFactory.getConnector("OCXXX"), SERVICE_CACHE, params); - - if (data == null) { - return Collections.emptyList(); - } - - final BufferedInputStream stream = new BufferedInputStream(new GZIPInputStream(data)); - final Collection<Geocache> result = OC11XMLParser.parseCachesFiltered(stream); - IOUtils.closeQuietly(stream); - return result; - } catch (IOException e) { - Log.e("Error parsing nearby search result", e); - return Collections.emptyList(); - } - } - - private static InputStream request(final IConnector connector, final String service, final Parameters params) { - if (connector == null) { - return null; - } - if (!(connector instanceof OCXMLApiConnector)) { - return null; - } - - final String host = connector.getHost(); - if (StringUtils.isBlank(host)) { - return null; - } - - final String uri = "http://" + host + service; - HttpResponse resp = Network.getRequest(uri, params); - if (resp != null) { - try { - return resp.getEntity().getContent(); - } catch (IllegalStateException e) { - // fall through and return null - } catch (IOException e) { - // fall through and return null - } - } - return null; - } - - private static Parameters getOCXmlQueryParameters(final boolean withDescription, final boolean withLogs, final boolean withImages) { - return new Parameters("modifiedsince", "20000101000000", - "user", "0", - "cache", "1", - "cachedesc", withDescription ? "1" : "0", - "cachelog", withLogs ? "1" : "0", - "picture", withImages ? "1" : "0", - "removedobject", "0", - "session", "0", - "doctype", "0", - "charset", "utf-8", - "zip", "gzip", - "picturefromcachelog", withImages ? "1" : "0"); - } -} diff --git a/main/src/cgeo/geocaching/connector/oc/OkapiClient.java b/main/src/cgeo/geocaching/connector/oc/OkapiClient.java index 0673605..d8d92e1 100644 --- a/main/src/cgeo/geocaching/connector/oc/OkapiClient.java +++ b/main/src/cgeo/geocaching/connector/oc/OkapiClient.java @@ -3,16 +3,27 @@ package cgeo.geocaching.connector.oc; import cgeo.geocaching.Geocache; import cgeo.geocaching.Image; import cgeo.geocaching.LogEntry; +import cgeo.geocaching.R; +import cgeo.geocaching.Settings; +import cgeo.geocaching.Waypoint; import cgeo.geocaching.cgData; +import cgeo.geocaching.cgeoapplication; import cgeo.geocaching.connector.ConnectorFactory; import cgeo.geocaching.connector.IConnector; +import cgeo.geocaching.connector.LogResult; +import cgeo.geocaching.connector.gc.GCConnector; +import cgeo.geocaching.enumerations.CacheAttribute; import cgeo.geocaching.enumerations.CacheSize; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.enumerations.LoadFlags.SaveFlag; import cgeo.geocaching.enumerations.LogType; +import cgeo.geocaching.enumerations.StatusCode; +import cgeo.geocaching.enumerations.WaypointType; import cgeo.geocaching.geopoint.Geopoint; import cgeo.geocaching.geopoint.GeopointFormatter; +import cgeo.geocaching.geopoint.Viewport; import cgeo.geocaching.network.Network; +import cgeo.geocaching.network.OAuth; import cgeo.geocaching.network.Parameters; import cgeo.geocaching.utils.Log; @@ -22,17 +33,40 @@ import org.json.JSONException; import org.json.JSONObject; import android.net.Uri; -import android.text.Html; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; +import java.util.Calendar; +import java.util.Collections; import java.util.Date; import java.util.EnumSet; +import java.util.Iterator; +import java.util.LinkedHashMap; import java.util.List; import java.util.Locale; +import java.util.Map; +import java.util.TimeZone; final public class OkapiClient { + + private static final SimpleDateFormat logDateFormat; + + static { + logDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSSZ", Locale.US); + logDateFormat.setTimeZone(TimeZone.getTimeZone("UTC")); + } + + private static final String CACHE_ATTRNAMES = "attrnames"; + private static final String WPT_LOCATION = "location"; + private static final String WPT_DESCRIPTION = "description"; + private static final String WPT_TYPE = "type"; + private static final String WPT_NAME = "name"; + private static final String CACHE_IS_WATCHED = "is_watched"; + private static final String CACHE_WPTS = "alt_wpts"; + private static final String CACHE_STATUS_ARCHIVED = "Archived"; + private static final String CACHE_STATUS_DISABLED = "Temporarily unavailable"; + private static final String CACHE_IS_FOUND = "is_found"; private static final String CACHE_SIZE = "size"; private static final String CACHE_VOTES = "rating_votes"; private static final String CACHE_NOTFOUNDS = "notfounds"; @@ -64,12 +98,22 @@ final public class OkapiClient { private static final String USER_USERNAME = "username"; private static final String SERVICE_CACHE = "/okapi/services/caches/geocache"; - private static final String SERVICE_CACHE_FIELDS = "code|name|location|type|status|owner|founds|notfounds|size|difficulty|terrain|rating|rating_votes|recommendations|description|hint|images|latest_logs|date_hidden"; - private static final String SERVICE_NEAREST = "/okapi/services/caches/search/nearest"; + private static final String SERVICE_CACHE_CORE_FIELDS = "code|name|location|type|status|difficulty|terrain|size|is_found"; + private static final String SERVICE_CACHE_FIELDS = SERVICE_CACHE_CORE_FIELDS + "|owner|founds|notfounds|rating|rating_votes|recommendations|description|hint|images|latest_logs|date_hidden|attribution_note|alt_wpts|is_watched|attrnames|gc_code"; + + private static final String SERVICE_SEARCH_AND_RETRIEVE = "/okapi/services/caches/shortcuts/search_and_retrieve"; + + private static final String METHOD_SEARCH_NEAREST = "services/caches/search/nearest"; + private static final String METHOD_SEARCH_BBOX = "services/caches/search/bbox"; + private static final String METHOD_RETRIEVE_CACHES = "services/caches/geocaches"; + + private static final String SERVICE_MARK_CACHE = "/okapi/services/caches/mark"; + + private static final String SERVICE_SUBMIT_LOG = "/okapi/services/logs/submit"; public static Geocache getCache(final String geoCode) { - final Parameters params = new Parameters("cache_code", geoCode, "fields", SERVICE_CACHE_FIELDS); + final Parameters params = new Parameters("cache_code", geoCode, "fields", SERVICE_CACHE_FIELDS, "attribution_append", "none"); final JSONObject data = request(ConnectorFactory.getConnector(geoCode), SERVICE_CACHE, params); if (data == null) { @@ -81,30 +125,115 @@ final public class OkapiClient { public static List<Geocache> getCachesAround(final Geopoint center, IConnector connector) { String centerString = GeopointFormatter.format(GeopointFormatter.Format.LAT_DECDEGREE_RAW, center) + "|" + GeopointFormatter.format(GeopointFormatter.Format.LON_DECDEGREE_RAW, center); - final Parameters params = new Parameters("center", centerString); - final JSONObject data = request(connector, SERVICE_NEAREST, params); + final Parameters params = new Parameters("search_method", METHOD_SEARCH_NEAREST); + final Map<String, String> valueMap = new LinkedHashMap<String, String>(); + valueMap.put("center", centerString); + valueMap.put("limit", "20"); + + addFilterParams(valueMap); + + params.add("search_params", new JSONObject(valueMap).toString()); + + addRetrieveParams(params); + + final JSONObject data = request(connector, SERVICE_SEARCH_AND_RETRIEVE, params); if (data == null) { - return null; + return Collections.emptyList(); + } + + return parseCaches(data); + } + + public static List<Geocache> getCachesBBox(final Viewport viewport, IConnector connector) { + + if (viewport.getLatitudeSpan() == 0 || viewport.getLongitudeSpan() == 0) { + return Collections.emptyList(); + } + + String bboxString = GeopointFormatter.format(GeopointFormatter.Format.LAT_DECDEGREE_RAW, viewport.bottomLeft) + + "|" + GeopointFormatter.format(GeopointFormatter.Format.LON_DECDEGREE_RAW, viewport.bottomLeft) + + "|" + GeopointFormatter.format(GeopointFormatter.Format.LAT_DECDEGREE_RAW, viewport.topRight) + + "|" + GeopointFormatter.format(GeopointFormatter.Format.LON_DECDEGREE_RAW, viewport.topRight); + final Parameters params = new Parameters("search_method", METHOD_SEARCH_BBOX); + final Map<String, String> valueMap = new LinkedHashMap<String, String>(); + valueMap.put("bbox", bboxString); + + addFilterParams(valueMap); + + params.add("search_params", new JSONObject(valueMap).toString()); + + addRetrieveParams(params); + + final JSONObject data = request(connector, SERVICE_SEARCH_AND_RETRIEVE, params); + + if (data == null) { + return Collections.emptyList(); } return parseCaches(data); } + public static boolean setWatchState(final Geocache cache, final boolean watched, IConnector connector) { + final Parameters params = new Parameters("cache_code", cache.getGeocode()); + params.add("watched", watched ? "true" : "false"); + + final JSONObject data = request(connector, SERVICE_MARK_CACHE, params); + + if (data == null) { + return false; + } + + cache.setOnWatchlist(watched); + + return true; + } + + public static LogResult postLog(final Geocache cache, LogType logType, Calendar date, String log, IConnector connector) { + final Parameters params = new Parameters("cache_code", cache.getGeocode()); + params.add("logtype", logType.oc_type); + params.add("comment", log); + params.add("comment_format", "plaintext"); + params.add("when", logDateFormat.format(date.getTime())); + if (logType.equals(LogType.NEEDS_MAINTENANCE)) { + params.add("needs_maintenance", "true"); + } + + final JSONObject data = request(connector, SERVICE_SUBMIT_LOG, params); + + if (data == null) { + return new LogResult(StatusCode.LOG_POST_ERROR, ""); + } + + try { + if (data.getBoolean("success")) { + return new LogResult(StatusCode.NO_ERROR, data.getString("log_uuid")); + } + + return new LogResult(StatusCode.LOG_POST_ERROR, ""); + } catch (JSONException e) { + Log.e("OkapiClient.postLog", e); + } + return new LogResult(StatusCode.LOG_POST_ERROR, ""); + } + private static List<Geocache> parseCaches(final JSONObject response) { try { - final JSONArray cachesResponse = response.getJSONArray("results"); + // Check for empty result + final String result = response.getString("results"); + if (StringUtils.isBlank(result) || StringUtils.equals(result, "[]")) { + return Collections.emptyList(); + } + + // Get and iterate result list + final JSONObject cachesResponse = response.getJSONObject("results"); if (cachesResponse != null) { - ArrayList<String> geocodes = new ArrayList<String>(cachesResponse.length()); - for (int i = 0; i < cachesResponse.length(); i++) { - String geocode = cachesResponse.getString(i); - if (StringUtils.isNotBlank(geocode)) { - geocodes.add(geocode); - } - } - List<Geocache> caches = new ArrayList<Geocache>(geocodes.size()); - for (String geocode : geocodes) { - Geocache cache = getCache(geocode); + List<Geocache> caches = new ArrayList<Geocache>(cachesResponse.length()); + @SuppressWarnings("unchecked") + Iterator<String> keys = cachesResponse.keys(); + while (keys.hasNext()) { + String key = keys.next(); + Geocache cache = parseSmallCache(cachesResponse.getJSONObject(key)); if (cache != null) { caches.add(cache); } @@ -112,24 +241,31 @@ final public class OkapiClient { return caches; } } catch (JSONException e) { - Log.e("OkapiClient.parseCaches", e); + Log.e("OkapiClient.parseCachesResult", e); } - return null; + return Collections.emptyList(); + } + + private static Geocache parseSmallCache(final JSONObject response) { + final Geocache cache = new Geocache(); + cache.setReliableLatLon(true); + try { + + parseCoreCache(response, cache); + + cgData.saveCache(cache, EnumSet.of(SaveFlag.SAVE_CACHE)); + } catch (JSONException e) { + Log.e("OkapiClient.parseSmallCache", e); + } + return cache; } private static Geocache parseCache(final JSONObject response) { final Geocache cache = new Geocache(); cache.setReliableLatLon(true); try { - cache.setGeocode(response.getString(CACHE_CODE)); - cache.setName(response.getString(CACHE_NAME)); - // not used: names - setLocation(cache, response.getString(CACHE_LOCATION)); - cache.setType(getCacheType(response.getString(CACHE_TYPE))); - final String status = response.getString(CACHE_STATUS); - cache.setDisabled(status.equalsIgnoreCase("Temporarily unavailable")); - cache.setArchived(status.equalsIgnoreCase("Archived")); + parseCoreCache(response, cache); // not used: url final JSONObject owner = response.getJSONObject(CACHE_OWNER); @@ -137,9 +273,7 @@ final public class OkapiClient { cache.getLogCounts().put(LogType.FOUND_IT, response.getInt(CACHE_FOUNDS)); cache.getLogCounts().put(LogType.DIDNT_FIND_IT, response.getInt(CACHE_NOTFOUNDS)); - cache.setSize(getCacheSize(response)); - cache.setDifficulty((float) response.getDouble(CACHE_DIFFICULTY)); - cache.setTerrain((float) response.getDouble(CACHE_TERRAIN)); + if (!response.isNull(CACHE_RATING)) { cache.setRating((float) response.getDouble(CACHE_RATING)); } @@ -147,8 +281,22 @@ final public class OkapiClient { cache.setFavoritePoints(response.getInt(CACHE_RECOMMENDATIONS)); // not used: req_password - cache.setDescription(response.getString(CACHE_DESCRIPTION)); - cache.setHint(Html.fromHtml(response.getString(CACHE_HINT)).toString()); + // Prepend gc-link to description if available + StringBuilder description = new StringBuilder(500); + if (!response.isNull("gc_code")) { + String gccode = response.getString("gc_code"); + description.append(cgeoapplication.getInstance().getResources() + .getString(R.string.cache_listed_on, GCConnector.getInstance().getName())) + .append(": <a href=\"http://coord.info/") + .append(gccode) + .append("\">") + .append(gccode) + .append("</a><br /><br />"); + } + description.append(response.getString(CACHE_DESCRIPTION)); + cache.setDescription(description.toString()); + + cache.setHint(response.getString(CACHE_HINT)); // not used: hints final JSONArray images = response.getJSONArray(CACHE_IMAGES); @@ -163,9 +311,13 @@ final public class OkapiClient { } } - // not used: attrnames + cache.setAttributes(parseAttributes(response.getJSONArray(CACHE_ATTRNAMES))); cache.setLogs(parseLogs(response.getJSONArray(CACHE_LATEST_LOGS))); cache.setHidden(parseDate(response.getString(CACHE_HIDDEN))); + //TODO: Store license per cache + //cache.setLicense(response.getString("attribution_note")); + cache.setWaypoints(parseWaypoints(response.getJSONArray(CACHE_WPTS)), false); + cache.setOnWatchlist(response.getBoolean(CACHE_IS_WATCHED)); cache.setDetailedUpdatedNow(); // save full detailed caches @@ -176,6 +328,24 @@ final public class OkapiClient { return cache; } + private static void parseCoreCache(final JSONObject response, final Geocache cache) throws JSONException { + cache.setGeocode(response.getString(CACHE_CODE)); + cache.setName(response.getString(CACHE_NAME)); + // not used: names + setLocation(cache, response.getString(CACHE_LOCATION)); + cache.setType(getCacheType(response.getString(CACHE_TYPE))); + + final String status = response.getString(CACHE_STATUS); + cache.setDisabled(status.equalsIgnoreCase(CACHE_STATUS_DISABLED)); + cache.setArchived(status.equalsIgnoreCase(CACHE_STATUS_ARCHIVED)); + + cache.setSize(getCacheSize(response)); + cache.setDifficulty((float) response.getDouble(CACHE_DIFFICULTY)); + cache.setTerrain((float) response.getDouble(CACHE_TERRAIN)); + + cache.setFound(response.getBoolean(CACHE_IS_FOUND)); + } + private static String absoluteUrl(String url, String geocode) { final Uri uri = Uri.parse(url); @@ -214,6 +384,30 @@ final public class OkapiClient { return result; } + private static List<Waypoint> parseWaypoints(JSONArray wptsJson) { + List<Waypoint> result = null; + for (int i = 0; i < wptsJson.length(); i++) { + try { + JSONObject wptResponse = wptsJson.getJSONObject(i); + Waypoint wpt = new Waypoint(wptResponse.getString(WPT_NAME), + parseWptType(wptResponse.getString(WPT_TYPE)), + false); + wpt.setNote(wptResponse.getString(WPT_DESCRIPTION)); + Geopoint pt = parseCoords(wptResponse.getString(WPT_LOCATION)); + if (pt != null) { + wpt.setCoords(pt); + } + if (result == null) { + result = new ArrayList<Waypoint>(); + } + result.add(wpt); + } catch (JSONException e) { + Log.e("OkapiClient.parseWaypoints", e); + } + } + return result; + } + private static LogType parseLogType(String logType) { if ("Found it".equalsIgnoreCase(logType)) { return LogType.FOUND_IT; @@ -224,6 +418,31 @@ final public class OkapiClient { return LogType.NOTE; } + private static WaypointType parseWptType(String wptType) { + if ("parking".equalsIgnoreCase(wptType)) { + return WaypointType.PARKING; + } + if ("path".equalsIgnoreCase(wptType)) { + return WaypointType.TRAILHEAD; + } + if ("stage".equalsIgnoreCase(wptType)) { + return WaypointType.STAGE; + } + if ("physical-stage".equalsIgnoreCase(wptType)) { + return WaypointType.STAGE; + } + if ("virtual-stage".equalsIgnoreCase(wptType)) { + return WaypointType.PUZZLE; + } + if ("final".equalsIgnoreCase(wptType)) { + return WaypointType.FINAL; + } + if ("poi".equalsIgnoreCase(wptType)) { + return WaypointType.TRAILHEAD; + } + return WaypointType.WAYPOINT; + } + private static Date parseDate(final String date) { final SimpleDateFormat ISO8601DATEFORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ", Locale.getDefault()); final String strippedDate = date.replaceAll("\\+0([0-9]){1}\\:00", "+0$100"); @@ -235,6 +454,36 @@ final public class OkapiClient { return null; } + private static Geopoint parseCoords(final String location) { + final String latitude = StringUtils.substringBefore(location, "|"); + final String longitude = StringUtils.substringAfter(location, "|"); + if (StringUtils.isNotBlank(latitude) && StringUtils.isNotBlank(longitude)) { + return new Geopoint(latitude, longitude); + } + + return null; + } + + private static List<String> parseAttributes(JSONArray nameList) { + + List<String> result = new ArrayList<String>(); + + for (int i = 0; i < nameList.length(); i++) { + try { + String name = nameList.getString(i); + CacheAttribute attr = CacheAttribute.getByOcId(AttributeParser.getOcDeId(name)); + + if (attr != null) { + result.add(attr.rawName); + } + } catch (JSONException e) { + Log.e("OkapiClient.parseAttributes", e); + } + } + + return result; + } + private static void setLocation(final Geocache cache, final String location) { final String latitude = StringUtils.substringBefore(location, "|"); final String longitude = StringUtils.substringAfter(location, "|"); @@ -281,6 +530,18 @@ final public class OkapiClient { if (cacheType.equalsIgnoreCase("Virtual")) { return CacheType.VIRTUAL; } + if (cacheType.equalsIgnoreCase("Event")) { + return CacheType.EVENT; + } + if (cacheType.equalsIgnoreCase("Webcam")) { + return CacheType.WEBCAM; + } + if (cacheType.equalsIgnoreCase("Math/Physics")) { + return CacheType.MYSTERY; + } + if (cacheType.equalsIgnoreCase("Drive-In")) { + return CacheType.TRADITIONAL; + } return CacheType.UNKNOWN; } @@ -297,9 +558,10 @@ final public class OkapiClient { return null; } - ((OCApiConnector) connector).addAuthentication(params); params.add("langpref", getPreferredLanguage()); + OAuth.signOAuth(host, service, "GET", false, params, Settings.getOCDETokenPublic(), Settings.getOCDETokenSecret(), ((OCApiLiveConnector) connector).getCK(), ((OCApiLiveConnector) connector).getCS()); + final String uri = "http://" + host + service; return Network.requestJSON(uri, params); } @@ -311,4 +573,43 @@ final public class OkapiClient { } return "en"; } + + private static void addFilterParams(final Map<String, String> valueMap) { + if (!Settings.isExcludeDisabledCaches()) { + valueMap.put("status", "Available|Temporarily unavailable"); + } + if (Settings.isExcludeMyCaches()) { + valueMap.put("exclude_my_own", "true"); + valueMap.put("found_status", "notfound_only"); + } + if (Settings.getCacheType() != CacheType.ALL) { + valueMap.put("type", getFilterFromType(Settings.getCacheType())); + } + } + + private static void addRetrieveParams(final Parameters params) { + params.add("retr_method", METHOD_RETRIEVE_CACHES); + params.add("retr_params", "{\"fields\": \"" + SERVICE_CACHE_CORE_FIELDS + "\"}"); + params.add("wrap", "true"); + } + + private static String getFilterFromType(CacheType cacheType) { + switch (cacheType) { + case EVENT: + return "Event"; + case MULTI: + return "Multi"; + case MYSTERY: + return "Quiz"; + case TRADITIONAL: + return "Traditional"; + case VIRTUAL: + return "Virtual"; + case WEBCAM: + return "Webcam"; + default: + return ""; + } + } + } diff --git a/main/src/cgeo/geocaching/connector/oc/OkapiLoggingManager.java b/main/src/cgeo/geocaching/connector/oc/OkapiLoggingManager.java new file mode 100644 index 0000000..24c6b79 --- /dev/null +++ b/main/src/cgeo/geocaching/connector/oc/OkapiLoggingManager.java @@ -0,0 +1,69 @@ +package cgeo.geocaching.connector.oc; + +import cgeo.geocaching.Geocache; +import cgeo.geocaching.TrackableLog; +import cgeo.geocaching.VisitCacheActivity; +import cgeo.geocaching.connector.IConnector; +import cgeo.geocaching.connector.ILoggingManager; +import cgeo.geocaching.connector.ImageResult; +import cgeo.geocaching.connector.LogResult; +import cgeo.geocaching.enumerations.LogType; +import cgeo.geocaching.enumerations.StatusCode; + +import android.app.Activity; +import android.net.Uri; + +import java.util.Arrays; +import java.util.Calendar; +import java.util.Collections; +import java.util.List; + +public class OkapiLoggingManager implements ILoggingManager { + + private final IConnector connector; + private final Geocache cache; + private VisitCacheActivity activity; + + private final static List<LogType> standardLogTypes = Arrays.asList(LogType.FOUND_IT, LogType.DIDNT_FIND_IT, LogType.NOTE, LogType.NEEDS_MAINTENANCE); + private final static List<LogType> eventLogTypes = Arrays.asList(LogType.WILL_ATTEND, LogType.ATTENDED, LogType.NOTE); + + public OkapiLoggingManager(Activity activity, IConnector connector, Geocache cache) { + this.connector = connector; + this.cache = cache; + this.activity = (VisitCacheActivity) activity; + } + + @Override + public void init() { + activity.onLoadFinished(); + } + + @Override + public LogResult postLog(Geocache cache, LogType logType, Calendar date, String log, List<TrackableLog> trackableLogs) { + return OkapiClient.postLog(cache, logType, date, log, connector); + } + + @Override + public ImageResult postLogImage(String logId, String imageCaption, String imageDescription, Uri imageUri) { + return new ImageResult(StatusCode.LOG_POST_ERROR, ""); + } + + @Override + public boolean hasLoaderError() { + return false; + } + + @Override + public List<TrackableLog> getTrackables() { + return Collections.emptyList(); + } + + @Override + public List<LogType> getPossibleLogTypes() { + if (cache.isEventCache()) { + return eventLogTypes; + } + + return standardLogTypes; + } +} diff --git a/main/src/cgeo/geocaching/enumerations/LogType.java b/main/src/cgeo/geocaching/enumerations/LogType.java index 71a5146..9902d3f 100644 --- a/main/src/cgeo/geocaching/enumerations/LogType.java +++ b/main/src/cgeo/geocaching/enumerations/LogType.java @@ -15,50 +15,52 @@ import java.util.Map; */ public enum LogType { - FOUND_IT(2, "2", "found it", R.string.log_found, R.drawable.mark_green), - DIDNT_FIND_IT(3, "3", "didn't find it", R.string.log_dnf, R.drawable.mark_red), - NOTE(4, "4", "write note", R.string.log_note), - PUBLISH_LISTING(1003, "24", "publish listing", R.string.log_published, R.drawable.mark_green_more), - ENABLE_LISTING(23, "23", "enable listing", R.string.log_enabled, R.drawable.mark_green_more), - ARCHIVE(5, "5", "archive", R.string.log_archived, R.drawable.mark_red_more), - UNARCHIVE(12, "12", "unarchive", R.string.log_unarchived, R.drawable.mark_green_more), - TEMP_DISABLE_LISTING(22, "22", "temporarily disable listing", R.string.log_disabled, R.drawable.mark_red_more), - NEEDS_ARCHIVE(7, "7", "needs archived", R.string.log_needs_archived, R.drawable.mark_red), - WILL_ATTEND(9, "9", "will attend", R.string.log_attend), - ATTENDED(10, "10", "attended", R.string.log_attended, R.drawable.mark_green), - RETRIEVED_IT(13, "13", "retrieved it", R.string.log_retrieved, R.drawable.mark_green_more), - PLACED_IT(14, "14", "placed it", R.string.log_placed, R.drawable.mark_green_more), - GRABBED_IT(19, "19", "grabbed it", R.string.log_grabbed, R.drawable.mark_green_more), - NEEDS_MAINTENANCE(45, "45", "needs maintenance", R.string.log_maintenance_needed, R.drawable.mark_red), - OWNER_MAINTENANCE(46, "46", "owner maintenance", R.string.log_maintained, R.drawable.mark_green_more), - UPDATE_COORDINATES(47, "47", "update coordinates", R.string.log_update), - DISCOVERED_IT(48, "48", "discovered it", R.string.log_discovered, R.drawable.mark_green), - POST_REVIEWER_NOTE(18, "68", "post reviewer note", R.string.log_reviewer), - VISIT(1001, "75", "visit", R.string.log_tb_visit, R.drawable.mark_green), - WEBCAM_PHOTO_TAKEN(11, "11", "webcam photo taken", R.string.log_webcam, R.drawable.mark_green), - ANNOUNCEMENT(74, "74", "announcement", R.string.log_announcement), - MOVE_COLLECTION(69, "69", "unused_collection", R.string.log_movecollection), - MOVE_INVENTORY(70, "70", "unused_inventory", R.string.log_moveinventory), - RETRACT(25, "25", "retract listing", R.string.log_retractlisting), - MARKED_MISSING(16, "16", "marked missing", R.string.log_marked_missing, R.drawable.mark_red), - UNKNOWN(0, "unknown", "", R.string.err_unknown, R.drawable.mark_red); // LogType not init. yet + FOUND_IT(2, "2", "found it", "Found it", R.string.log_found, R.drawable.mark_green), + DIDNT_FIND_IT(3, "3", "didn't find it", "Didn't find it", R.string.log_dnf, R.drawable.mark_red), + NOTE(4, "4", "write note", "Comment", R.string.log_note), + PUBLISH_LISTING(1003, "24", "publish listing", "", R.string.log_published, R.drawable.mark_green_more), + ENABLE_LISTING(23, "23", "enable listing", "", R.string.log_enabled, R.drawable.mark_green_more), + ARCHIVE(5, "5", "archive", "", R.string.log_archived, R.drawable.mark_red_more), + UNARCHIVE(12, "12", "unarchive", "", R.string.log_unarchived, R.drawable.mark_green_more), + TEMP_DISABLE_LISTING(22, "22", "temporarily disable listing", "", R.string.log_disabled, R.drawable.mark_red_more), + NEEDS_ARCHIVE(7, "7", "needs archived", "", R.string.log_needs_archived, R.drawable.mark_red), + WILL_ATTEND(9, "9", "will attend", "Will attend", R.string.log_attend), + ATTENDED(10, "10", "attended", "Attended", R.string.log_attended, R.drawable.mark_green), + RETRIEVED_IT(13, "13", "retrieved it", "", R.string.log_retrieved, R.drawable.mark_green_more), + PLACED_IT(14, "14", "placed it", "", R.string.log_placed, R.drawable.mark_green_more), + GRABBED_IT(19, "19", "grabbed it", "", R.string.log_grabbed, R.drawable.mark_green_more), + NEEDS_MAINTENANCE(45, "45", "needs maintenance", "Comment", R.string.log_maintenance_needed, R.drawable.mark_red), + OWNER_MAINTENANCE(46, "46", "owner maintenance", "", R.string.log_maintained, R.drawable.mark_green_more), + UPDATE_COORDINATES(47, "47", "update coordinates", "", R.string.log_update), + DISCOVERED_IT(48, "48", "discovered it", "", R.string.log_discovered, R.drawable.mark_green), + POST_REVIEWER_NOTE(18, "68", "post reviewer note", "", R.string.log_reviewer), + VISIT(1001, "75", "visit", "", R.string.log_tb_visit, R.drawable.mark_green), + WEBCAM_PHOTO_TAKEN(11, "11", "webcam photo taken", "", R.string.log_webcam, R.drawable.mark_green), + ANNOUNCEMENT(74, "74", "announcement", "", R.string.log_announcement), + MOVE_COLLECTION(69, "69", "unused_collection", "", R.string.log_movecollection), + MOVE_INVENTORY(70, "70", "unused_inventory", "", R.string.log_moveinventory), + RETRACT(25, "25", "retract listing", "", R.string.log_retractlisting), + MARKED_MISSING(16, "16", "marked missing", "", R.string.log_marked_missing, R.drawable.mark_red), + UNKNOWN(0, "unknown", "", "", R.string.err_unknown, R.drawable.mark_red); // LogType not init. yet public final int id; public final String iconName; public final String type; + public final String oc_type; private final int stringId; public final int markerId; - LogType(int id, String iconName, String type, int stringId, int markerId) { + LogType(int id, String iconName, String type, String oc_type, int stringId, int markerId) { this.id = id; this.iconName = iconName; this.type = type; + this.oc_type = oc_type; this.stringId = stringId; this.markerId = markerId; } - LogType(int id, String iconName, String type, int stringId) { - this(id, iconName, type, stringId, R.drawable.mark_gray); + LogType(int id, String iconName, String type, String oc_type, int stringId) { + this(id, iconName, type, oc_type, stringId, R.drawable.mark_gray); } private final static Map<String, LogType> FIND_BY_ICONNAME; diff --git a/main/src/cgeo/geocaching/loaders/CoordsGeocacheListLoader.java b/main/src/cgeo/geocaching/loaders/CoordsGeocacheListLoader.java index ca2461c..09ea459 100644 --- a/main/src/cgeo/geocaching/loaders/CoordsGeocacheListLoader.java +++ b/main/src/cgeo/geocaching/loaders/CoordsGeocacheListLoader.java @@ -19,7 +19,11 @@ public class CoordsGeocacheListLoader extends AbstractSearchLoader { @Override public SearchResult runSearch() { - SearchResult search = GCParser.searchByCoords(coords, Settings.getCacheType(), Settings.isShowCaptcha(), this); + + SearchResult search = new SearchResult(); + if (Settings.isGCConnectorActive()) { + search = GCParser.searchByCoords(coords, Settings.getCacheType(), Settings.isShowCaptcha(), this); + } for (ISearchByCenter centerConn : ConnectorFactory.getSearchByCenterConnectors()) { if (centerConn.isActivated()) { diff --git a/main/src/cgeo/geocaching/maps/CGeoMap.java b/main/src/cgeo/geocaching/maps/CGeoMap.java index 0af0e6c..ea51375 100644 --- a/main/src/cgeo/geocaching/maps/CGeoMap.java +++ b/main/src/cgeo/geocaching/maps/CGeoMap.java @@ -1146,7 +1146,7 @@ public class CGeoMap extends AbstractMap implements OnMapDragListener, ViewFacto searchResult = ConnectorFactory.searchByViewport(viewport.resize(0.8), tokens); if (searchResult != null) { downloaded = true; - if (searchResult.getError() == StatusCode.NOT_LOGGED_IN) { + if (searchResult.getError() == StatusCode.NOT_LOGGED_IN && Settings.isGCConnectorActive()) { Login.login(); tokens = null; } else { diff --git a/main/src/cgeo/geocaching/network/OAuth.java b/main/src/cgeo/geocaching/network/OAuth.java index 0b7a261..6740096 100644 --- a/main/src/cgeo/geocaching/network/OAuth.java +++ b/main/src/cgeo/geocaching/network/OAuth.java @@ -1,9 +1,9 @@ package cgeo.geocaching.network; -import cgeo.geocaching.Settings; import cgeo.geocaching.utils.CryptUtils; import ch.boye.httpclientandroidlib.NameValuePair; + import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -11,9 +11,17 @@ import java.util.Date; import java.util.List; public class OAuth { - public static void signOAuth(final String host, final String path, final String method, final boolean https, final Parameters params, final String token, final String tokenSecret) { + public static void signOAuth(final String host, + final String path, + final String method, + final boolean https, + final Parameters params, + final String token, + final String tokenSecret, + final String consumerKey, + final String consumerSecret) { params.put( - "oauth_consumer_key", Settings.getKeyConsumerPublic(), + "oauth_consumer_key", consumerKey, "oauth_nonce", CryptUtils.md5(Long.toString(System.currentTimeMillis())), "oauth_signature_method", "HMAC-SHA1", "oauth_timestamp", Long.toString(new Date().getTime() / 1000), @@ -26,7 +34,7 @@ public class OAuth { paramsEncoded.add(nameValue.getName() + "=" + Network.rfc3986URLEncode(nameValue.getValue())); } - final String keysPacked = Settings.getKeyConsumerSecret() + "&" + StringUtils.defaultString(tokenSecret); // both even if empty some of them! + final String keysPacked = consumerSecret + "&" + StringUtils.defaultString(tokenSecret); // both even if empty some of them! final String requestPacked = method + "&" + Network.rfc3986URLEncode((https ? "https" : "http") + "://" + host + path) + "&" + Network.rfc3986URLEncode(StringUtils.join(paramsEncoded.toArray(), '&')); params.put("oauth_signature", CryptUtils.base64Encode(CryptUtils.hashHmac(requestPacked, keysPacked))); } diff --git a/main/src/cgeo/geocaching/network/OAuthAuthorizationActivity.java b/main/src/cgeo/geocaching/network/OAuthAuthorizationActivity.java new file mode 100644 index 0000000..751443e --- /dev/null +++ b/main/src/cgeo/geocaching/network/OAuthAuthorizationActivity.java @@ -0,0 +1,326 @@ +package cgeo.geocaching.network; + +import cgeo.geocaching.R; +import cgeo.geocaching.activity.AbstractActivity; +import cgeo.geocaching.utils.Log; +import cgeo.geocaching.utils.MatcherWrapper; + +import ch.boye.httpclientandroidlib.client.entity.UrlEncodedFormEntity; +import ch.boye.httpclientandroidlib.util.EntityUtils; + +import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; + +import android.app.ProgressDialog; +import android.content.Intent; +import android.net.Uri; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; +import android.view.View; +import android.widget.Button; +import android.widget.EditText; +import android.widget.TextView; + +import java.util.regex.Pattern; + +public abstract class OAuthAuthorizationActivity extends AbstractActivity { + + private String host; + private String pathRequest; + private String pathAuthorize; + private String pathAccess; + private boolean https; + private String consumerKey; + private String consumerSecret; + private String OAtoken = null; + private String OAtokenSecret = null; + private final Pattern paramsPattern1 = Pattern.compile("oauth_token=([a-zA-Z0-9\\-\\_.]+)"); + private final Pattern paramsPattern2 = Pattern.compile("oauth_token_secret=([a-zA-Z0-9\\-\\_.]+)"); + private Button startButton = null; + private EditText pinEntry = null; + private Button pinEntryButton = null; + private ProgressDialog requestTokenDialog = null; + private ProgressDialog changeTokensDialog = null; + private Handler requestTokenHandler = new Handler() { + + @Override + public void handleMessage(Message msg) { + if (requestTokenDialog != null && requestTokenDialog.isShowing()) { + requestTokenDialog.dismiss(); + } + + startButton.setOnClickListener(new StartListener()); + startButton.setEnabled(true); + + if (msg.what == 1) { + startButton.setText(getAuthAgain()); + + pinEntry.setVisibility(View.VISIBLE); + pinEntryButton.setVisibility(View.VISIBLE); + pinEntryButton.setOnClickListener(new ConfirmPINListener()); + } else { + showToast(getErrAuthInitialize()); + startButton.setText(getAuthStart()); + } + } + + }; + private Handler changeTokensHandler = new Handler() { + + @Override + public void handleMessage(Message msg) { + if (changeTokensDialog != null && changeTokensDialog.isShowing()) { + changeTokensDialog.dismiss(); + } + + pinEntryButton.setOnClickListener(new ConfirmPINListener()); + pinEntryButton.setEnabled(true); + + if (msg.what == 1) { + showToast(getAuthDialogCompleted()); + + pinEntryButton.setVisibility(View.GONE); + + finish(); + } else { + showToast(getErrAuthProcess()); + + pinEntry.setVisibility(View.GONE); + pinEntryButton.setVisibility(View.GONE); + startButton.setText(getAuthStart()); + } + } + }; + + public OAuthAuthorizationActivity(String host, + String pathRequest, + String pathAuthorize, + String pathAccess, + boolean https, + String consumerKey, + String consumerSecret) { + this.host = host; + this.pathRequest = pathRequest; + this.pathAuthorize = pathAuthorize; + this.pathAccess = pathAccess; + this.https = https; + this.consumerKey = consumerKey; + this.consumerSecret = consumerSecret; + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState, R.layout.authorization_activity); + + setTitle(getAuthTitle()); + + init(); + } + + private void init() { + startButton = (Button) findViewById(R.id.start); + pinEntry = (EditText) findViewById(R.id.pin); + pinEntryButton = (Button) findViewById(R.id.pin_button); + + TextView auth = (TextView) findViewById(R.id.auth_1); + auth.setText(getAboutAuth1()); + auth = (TextView) findViewById(R.id.auth_2); + auth.setText(getAboutAuth2()); + + ImmutablePair<String, String> tempToken = getTempToken(); + OAtoken = tempToken.left; + OAtokenSecret = tempToken.right; + + startButton.setText(getAuthAuthorize()); + pinEntryButton.setText(getAuthFinish()); + + startButton.setEnabled(true); + startButton.setOnClickListener(new StartListener()); + + if (StringUtils.isBlank(OAtoken) && StringUtils.isBlank(OAtokenSecret)) { + // start authorization process + startButton.setText(getAuthStart()); + } else { + // already have temporary tokens, continue from pin + startButton.setText(getAuthAgain()); + + pinEntry.setHint(getAuthPinHint()); + pinEntry.setVisibility(View.VISIBLE); + pinEntryButton.setVisibility(View.VISIBLE); + pinEntryButton.setOnClickListener(new ConfirmPINListener()); + } + } + + private void requestToken() { + + int status = 0; + try { + final Parameters params = new Parameters(); + params.put("oauth_callback", "oob"); + final String method = "GET"; + OAuth.signOAuth(host, pathRequest, method, https, params, null, null, consumerKey, consumerSecret); + final String line = Network.getResponseData(Network.getRequest(getUrlPrefix() + host + pathRequest, params)); + + if (StringUtils.isNotBlank(line)) { + final MatcherWrapper paramsMatcher1 = new MatcherWrapper(paramsPattern1, line); + if (paramsMatcher1.find()) { + OAtoken = paramsMatcher1.group(1); + } + final MatcherWrapper paramsMatcher2 = new MatcherWrapper(paramsPattern2, line); + if (paramsMatcher2.find()) { + OAtokenSecret = paramsMatcher2.group(1); + } + + if (StringUtils.isNotBlank(OAtoken) && StringUtils.isNotBlank(OAtokenSecret)) { + setTempTokens(OAtoken, OAtokenSecret); + try { + final Parameters paramsBrowser = new Parameters(); + paramsBrowser.put("oauth_token", OAtoken); + final String encodedParams = EntityUtils.toString(new UrlEncodedFormEntity(paramsBrowser)); + startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(getUrlPrefix() + host + pathAuthorize + "?" + encodedParams))); + status = 1; + } catch (Exception e) { + Log.e("OAuthAuthorizationActivity.requestToken(2)", e); + } + } + } + } catch (Exception e) { + Log.e("OAuthAuthorizationActivity.requestToken(1)", e); + } + + requestTokenHandler.sendEmptyMessage(status); + } + + private void changeToken() { + + int status = 0; + + try { + final Parameters params = new Parameters("oauth_verifier", pinEntry.getText().toString()); + + final String method = "POST"; + OAuth.signOAuth(host, pathAccess, method, https, params, OAtoken, OAtokenSecret, consumerKey, consumerSecret); + final String line = StringUtils.defaultString(Network.getResponseData(Network.postRequest(getUrlPrefix() + host + pathAccess, params))); + + OAtoken = ""; + OAtokenSecret = ""; + + final MatcherWrapper paramsMatcher1 = new MatcherWrapper(paramsPattern1, line); + if (paramsMatcher1.find()) { + OAtoken = paramsMatcher1.group(1); + } + final MatcherWrapper paramsMatcher2 = new MatcherWrapper(paramsPattern2, line); + if (paramsMatcher2.find() && paramsMatcher2.groupCount() > 0) { + OAtokenSecret = paramsMatcher2.group(1); + } + + if (StringUtils.isBlank(OAtoken) && StringUtils.isBlank(OAtokenSecret)) { + OAtoken = ""; + OAtokenSecret = ""; + setTokens(null, null, false); + } else { + setTokens(OAtoken, OAtokenSecret, true); + status = 1; + } + } catch (Exception e) { + Log.e("OAuthAuthorizationActivity.changeToken", e); + } + + changeTokensHandler.sendEmptyMessage(status); + } + + private String getUrlPrefix() { + return https ? "https://" : "http://"; + } + + private class StartListener implements View.OnClickListener { + + @Override + public void onClick(View arg0) { + if (requestTokenDialog == null) { + requestTokenDialog = new ProgressDialog(OAuthAuthorizationActivity.this); + requestTokenDialog.setCancelable(false); + requestTokenDialog.setMessage(getAuthDialogWait()); + } + requestTokenDialog.show(); + startButton.setEnabled(false); + startButton.setOnTouchListener(null); + startButton.setOnClickListener(null); + + setTempTokens(null, null); + (new Thread() { + + @Override + public void run() { + requestToken(); + } + }).start(); + } + } + + private class ConfirmPINListener implements View.OnClickListener { + + @Override + public void onClick(View arg0) { + if (StringUtils.isEmpty(((EditText) findViewById(R.id.pin)).getText().toString())) { + helpDialog(getAuthDialogPinTitle(), getAuthDialogPinMessage()); + return; + } + + if (changeTokensDialog == null) { + changeTokensDialog = new ProgressDialog(OAuthAuthorizationActivity.this); + changeTokensDialog.setCancelable(false); + changeTokensDialog.setMessage(getAuthDialogWait()); + } + changeTokensDialog.show(); + pinEntryButton.setEnabled(false); + pinEntryButton.setOnTouchListener(null); + pinEntryButton.setOnClickListener(null); + + (new Thread() { + + @Override + public void run() { + changeToken(); + } + }).start(); + } + } + + protected abstract ImmutablePair<String, String> getTempToken(); + + protected abstract void setTempTokens(String tokenPublic, String tokenSecret); + + protected abstract void setTokens(String tokenPublic, String tokenSecret, boolean enable); + + // get resources from derived class + + protected abstract String getAuthTitle(); + + protected abstract String getAuthAgain(); + + protected abstract String getErrAuthInitialize(); + + protected abstract String getAuthStart(); + + protected abstract String getAuthDialogCompleted(); + + protected abstract String getErrAuthProcess(); + + protected abstract String getAuthDialogWait(); + + protected abstract String getAuthDialogPinTitle(); + + protected abstract String getAuthDialogPinMessage(); + + protected abstract String getAboutAuth1(); + + protected abstract String getAboutAuth2(); + + protected abstract String getAuthAuthorize(); + + protected abstract String getAuthPinHint(); + + protected abstract String getAuthFinish(); +} diff --git a/main/src/cgeo/geocaching/twitter/Twitter.java b/main/src/cgeo/geocaching/twitter/Twitter.java index e3d3f77..525b7f0 100644 --- a/main/src/cgeo/geocaching/twitter/Twitter.java +++ b/main/src/cgeo/geocaching/twitter/Twitter.java @@ -38,7 +38,7 @@ public final class Twitter { "display_coordinates", "true"); } - OAuth.signOAuth("api.twitter.com", "/1/statuses/update.json", "POST", false, parameters, Settings.getTokenPublic(), Settings.getTokenSecret()); + OAuth.signOAuth("api.twitter.com", "/1/statuses/update.json", "POST", false, parameters, Settings.getTokenPublic(), Settings.getTokenSecret(), Settings.getKeyConsumerPublic(), Settings.getKeyConsumerSecret()); final HttpResponse httpResponse = Network.postRequest("http://api.twitter.com/1/statuses/update.json", parameters); if (httpResponse != null && httpResponse.getStatusLine().getStatusCode() == 200) { Log.i("Tweet posted"); diff --git a/main/src/cgeo/geocaching/twitter/TwitterAuthorizationActivity.java b/main/src/cgeo/geocaching/twitter/TwitterAuthorizationActivity.java index 3bc1dec..7146a62 100644 --- a/main/src/cgeo/geocaching/twitter/TwitterAuthorizationActivity.java +++ b/main/src/cgeo/geocaching/twitter/TwitterAuthorizationActivity.java @@ -2,258 +2,105 @@ package cgeo.geocaching.twitter; import cgeo.geocaching.R; import cgeo.geocaching.Settings; -import cgeo.geocaching.activity.AbstractActivity; -import cgeo.geocaching.network.Network; -import cgeo.geocaching.network.OAuth; -import cgeo.geocaching.network.Parameters; -import cgeo.geocaching.utils.Log; -import cgeo.geocaching.utils.MatcherWrapper; +import cgeo.geocaching.network.OAuthAuthorizationActivity; -import ch.boye.httpclientandroidlib.client.entity.UrlEncodedFormEntity; -import ch.boye.httpclientandroidlib.util.EntityUtils; - -import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.tuple.ImmutablePair; -import android.app.ProgressDialog; -import android.content.Intent; -import android.net.Uri; -import android.os.Bundle; -import android.os.Handler; -import android.os.Message; -import android.view.View; -import android.widget.Button; -import android.widget.EditText; - -import java.util.regex.Pattern; - -public class TwitterAuthorizationActivity extends AbstractActivity { - private String OAtoken = null; - private String OAtokenSecret = null; - private final Pattern paramsPattern1 = Pattern.compile("oauth_token=([a-zA-Z0-9\\-\\_.]+)"); - private final Pattern paramsPattern2 = Pattern.compile("oauth_token_secret=([a-zA-Z0-9\\-\\_.]+)"); - private Button startButton = null; - private EditText pinEntry = null; - private Button pinEntryButton = null; - private ProgressDialog requestTokenDialog = null; - private ProgressDialog changeTokensDialog = null; - private Handler requestTokenHandler = new Handler() { - - @Override - public void handleMessage(Message msg) { - if (requestTokenDialog != null && requestTokenDialog.isShowing()) { - requestTokenDialog.dismiss(); - } - - startButton.setOnClickListener(new StartListener()); - startButton.setEnabled(true); - - if (msg.what == 1) { - startButton.setText(res.getString(R.string.auth_again)); - - pinEntry.setVisibility(View.VISIBLE); - pinEntryButton.setVisibility(View.VISIBLE); - pinEntryButton.setOnClickListener(new ConfirmPINListener()); - } else { - showToast(res.getString(R.string.err_auth_initialize)); - startButton.setText(res.getString(R.string.auth_start)); - } - } - }; - private Handler changeTokensHandler = new Handler() { +public class TwitterAuthorizationActivity extends OAuthAuthorizationActivity { - @Override - public void handleMessage(Message msg) { - if (changeTokensDialog != null && changeTokensDialog.isShowing()) { - changeTokensDialog.dismiss(); - } - - pinEntryButton.setOnClickListener(new ConfirmPINListener()); - pinEntryButton.setEnabled(true); - - if (msg.what == 1) { - showToast(res.getString(R.string.auth_dialog_completed)); - - pinEntryButton.setVisibility(View.GONE); - - finish(); - } else { - showToast(res.getString(R.string.err_auth_process)); - - pinEntry.setVisibility(View.GONE); - pinEntryButton.setVisibility(View.GONE); - startButton.setText(res.getString(R.string.auth_start)); - } - } - }; + public TwitterAuthorizationActivity() { + super("api.twitter.com", + "/oauth/request_token", + "/oauth/authorize", + "/oauth/access_token", + true, + Settings.getKeyConsumerPublic(), + Settings.getKeyConsumerSecret()); + } @Override - public void onCreate(Bundle savedInstanceState) { - super.onCreate(savedInstanceState, R.layout.twitter_authorization_activity); - - init(); + protected ImmutablePair<String, String> getTempToken() { + return Settings.getTempToken(); } - private void init() { - startButton = (Button) findViewById(R.id.start); - pinEntry = (EditText) findViewById(R.id.pin); - pinEntryButton = (Button) findViewById(R.id.pin_button); - - ImmutablePair<String, String> tempToken = Settings.getTempToken(); - OAtoken = tempToken.left; - OAtokenSecret = tempToken.right; - - startButton.setEnabled(true); - startButton.setOnClickListener(new StartListener()); - - if (StringUtils.isBlank(OAtoken) && StringUtils.isBlank(OAtokenSecret)) { - // start authorization process - startButton.setText(res.getString(R.string.auth_start)); - } else { - // already have temporary tokens, continue from pin - startButton.setText(res.getString(R.string.auth_again)); - - pinEntry.setVisibility(View.VISIBLE); - pinEntryButton.setVisibility(View.VISIBLE); - pinEntryButton.setOnClickListener(new ConfirmPINListener()); - } + @Override + protected void setTempTokens(String tokenPublic, String tokenSecret) { + Settings.setTwitterTempTokens(tokenPublic, tokenSecret); } - private void requestToken() { - - int status = 0; - try { - final Parameters params = new Parameters(); - final String method = "GET"; - final String pathRequest = "/oauth/request_token"; - final String host = "api.twitter.com"; - OAuth.signOAuth(host, pathRequest, method, true, params, null, null); - final String line = Network.getResponseData(Network.getRequest("https://" + host + pathRequest, params)); - - - if (StringUtils.isNotBlank(line)) { - final MatcherWrapper paramsMatcher1 = new MatcherWrapper(paramsPattern1, line); - if (paramsMatcher1.find()) { - OAtoken = paramsMatcher1.group(1); - } - final MatcherWrapper paramsMatcher2 = new MatcherWrapper(paramsPattern2, line); - if (paramsMatcher2.find()) { - OAtokenSecret = paramsMatcher2.group(1); - } - - if (StringUtils.isNotBlank(OAtoken) && StringUtils.isNotBlank(OAtokenSecret)) { - Settings.setTwitterTempTokens(OAtoken, OAtokenSecret); - try { - final Parameters paramsBrowser = new Parameters(); - paramsBrowser.put("oauth_callback", "oob"); - final String pathAuthorize = "/oauth/authorize"; - OAuth.signOAuth(host, pathAuthorize, "GET", true, paramsBrowser, OAtoken, OAtokenSecret); - final String encodedParams = EntityUtils.toString(new UrlEncodedFormEntity(paramsBrowser)); - startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://" + host + pathAuthorize + "?" + encodedParams))); - status = 1; - } catch (Exception e) { - Log.e("TwitterAuthorizationActivity.requestToken(2)", e); - } - } - } - } catch (Exception e) { - Log.e("TwitterAuthorizationActivity.requestToken(1)", e); - } - - requestTokenHandler.sendEmptyMessage(status); + @Override + protected void setTokens(String tokenPublic, String tokenSecret, boolean enable) { + Settings.setTwitterTokens(tokenPublic, tokenSecret, enable); } - private void changeToken() { - - int status = 0; - - try { - final Parameters params = new Parameters("oauth_verifier", pinEntry.getText().toString()); - - final String method = "POST"; - final String path = "/oauth/access_token"; - final String host = "api.twitter.com"; - OAuth.signOAuth(host, path, method, true, params, OAtoken, OAtokenSecret); - final String line = StringUtils.defaultString(Network.getResponseData(Network.postRequest("https://" + host + path, params))); + @Override + protected String getAuthTitle() { + return res.getString(R.string.auth_twitter); + } - OAtoken = ""; - OAtokenSecret = ""; + @Override + protected String getAuthAgain() { + return res.getString(R.string.auth_again); + } - final MatcherWrapper paramsMatcher1 = new MatcherWrapper(paramsPattern1, line); - if (paramsMatcher1.find()) { - OAtoken = paramsMatcher1.group(1); - } - final MatcherWrapper paramsMatcher2 = new MatcherWrapper(paramsPattern2, line); - if (paramsMatcher2.find() && paramsMatcher2.groupCount() > 0) { - OAtokenSecret = paramsMatcher2.group(1); - } + @Override + protected String getErrAuthInitialize() { + return res.getString(R.string.err_auth_initialize); + } - if (StringUtils.isBlank(OAtoken) && StringUtils.isBlank(OAtokenSecret)) { - OAtoken = ""; - OAtokenSecret = ""; - Settings.setTwitterTokens(null, null, false); - } else { - Settings.setTwitterTokens(OAtoken, OAtokenSecret, true); - status = 1; - } - } catch (Exception e) { - Log.e("TwitterAuthorizationActivity.changeToken", e); - } + @Override + protected String getAuthStart() { + return res.getString(R.string.auth_start); + } - changeTokensHandler.sendEmptyMessage(status); + @Override + protected String getAuthDialogCompleted() { + return res.getString(R.string.auth_dialog_completed); } - private class StartListener implements View.OnClickListener { + @Override + protected String getErrAuthProcess() { + return res.getString(R.string.err_auth_process); + } - @Override - public void onClick(View arg0) { - if (requestTokenDialog == null) { - requestTokenDialog = new ProgressDialog(TwitterAuthorizationActivity.this); - requestTokenDialog.setCancelable(false); - requestTokenDialog.setMessage(res.getString(R.string.auth_dialog_wait)); - } - requestTokenDialog.show(); - startButton.setEnabled(false); - startButton.setOnTouchListener(null); - startButton.setOnClickListener(null); + @Override + protected String getAuthDialogWait() { + return res.getString(R.string.auth_dialog_wait); + } - Settings.setTwitterTempTokens(null, null); - (new Thread() { + @Override + protected String getAuthDialogPinTitle() { + return res.getString(R.string.auth_dialog_pin_title); + } - @Override - public void run() { - requestToken(); - } - }).start(); - } + @Override + protected String getAuthDialogPinMessage() { + return res.getString(R.string.auth_dialog_pin_message); } - private class ConfirmPINListener implements View.OnClickListener { + @Override + protected String getAboutAuth1() { + return res.getString(R.string.about_auth_1); + } - @Override - public void onClick(View arg0) { - if (StringUtils.isEmpty(((EditText) findViewById(R.id.pin)).getText().toString())) { - helpDialog(res.getString(R.string.auth_dialog_pin_title), res.getString(R.string.auth_dialog_pin_message)); - return; - } + @Override + protected String getAboutAuth2() { + return res.getString(R.string.about_auth_2); + } - if (changeTokensDialog == null) { - changeTokensDialog = new ProgressDialog(TwitterAuthorizationActivity.this); - changeTokensDialog.setCancelable(false); - changeTokensDialog.setMessage(res.getString(R.string.auth_dialog_wait)); - } - changeTokensDialog.show(); - pinEntryButton.setEnabled(false); - pinEntryButton.setOnTouchListener(null); - pinEntryButton.setOnClickListener(null); + @Override + protected String getAuthAuthorize() { + return res.getString(R.string.auth_authorize); + } - (new Thread() { + @Override + protected String getAuthPinHint() { + return res.getString(R.string.auth_pin_hint); + } - @Override - public void run() { - changeToken(); - } - }).start(); - } + @Override + protected String getAuthFinish() { + return res.getString(R.string.auth_finish); } + } diff --git a/main/templates/ocde_okapi.xml b/main/templates/ocde_okapi.xml new file mode 100644 index 0000000..9ca39b3 --- /dev/null +++ b/main/templates/ocde_okapi.xml @@ -0,0 +1,5 @@ +<?xml version="1.0" encoding="UTF-8"?> +<resources> + <string name="oc_de_okapi_consumer_key" translatable="false">@ocde.okapi.consumer.key@</string> + <string name="oc_de_okapi_consumer_secret" translatable="false">@ocde.okapi.consumer.secret@</string> +</resources> diff --git a/main/templates/private.properties b/main/templates/private.properties index f29cb7c..13c424b 100644 --- a/main/templates/private.properties +++ b/main/templates/private.properties @@ -16,3 +16,10 @@ maps.api.key.market= #key.alias= #key.store.password= #key.alias.password= + +# These keys allow c:geo to be registered at openaching.de and +# to search and log caches in your name +# You can request your own at http://www.opencaching.de/okapi/signup.html + +ocde.okapi.consumer.key= +ocde.okapi.consumer.secret= |