code stringlengths 1 2.01M | repo_name stringlengths 3 62 | path stringlengths 1 267 | language stringclasses 231
values | license stringclasses 13
values | size int64 1 2.01M |
|---|---|---|---|---|---|
// Copyright 2009 Gert Scholten
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.v2_0;
import org.rapla.rest.gwtjsonrpc.client.JsonUtil;
import org.rapla.rest.gwtjsonrpc.client.RemoteJsonException;
import org.rapla.rest.gwtjsonrpc.client.event.RpcCompleteEvent;
import org.rapla.rest.gwtjsonrpc.client.impl.AbstractJsonProxy;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonCall;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import org.rapla.rest.gwtjsonrpc.common.JsonConstants;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.user.client.rpc.InvocationException;
import com.google.gwt.user.client.rpc.StatusCodeException;
/** Base JsonCall implementation for JsonRPC version 2.0 */
abstract class JsonCall20<T> extends JsonCall<T> {
protected static int lastRequestId = 0;
protected int requestId;
JsonCall20(AbstractJsonProxy abstractJsonProxy, String methodName,
String requestParams, ResultDeserializer<T> resultDeserializer) {
super(abstractJsonProxy, methodName, requestParams, resultDeserializer);
}
@Override
public void onResponseReceived(final Request req, final Response rsp) {
final int sc = rsp.getStatusCode();
if (isJsonBody(rsp)) {
final RpcResult r;
try {
r = parse(jsonParser, rsp.getText());
} catch (RuntimeException e) {
RpcCompleteEvent.fire(this);
callback.onFailure(new InvocationException("Bad JSON response: " + e));
return;
}
if (r.error() != null) {
// TODO: define status code for the invalid XSRF msg for 2.0 (-32099 ?)
final String errmsg = r.error().message();
if (JsonConstants.ERROR_INVALID_XSRF.equals(errmsg)) {
if (attempts < 2) {
// The XSRF cookie was invalidated (or didn't exist) and the
// service demands we have one in place to make calls to it.
// A new token was returned to us, so start the request over.
//
send();
} else {
RpcCompleteEvent.fire(this);
callback.onFailure(new InvocationException(errmsg));
}
} else {
RpcCompleteEvent.fire(this);
callback.onFailure(new RemoteJsonException(errmsg, r.error().code(),
new JSONObject(r.error()).get("data")));
}
return;
}
if (sc == Response.SC_OK) {
RpcCompleteEvent.fire(this);
JsonUtil.invoke(resultDeserializer, callback, r);
return;
}
}
if (sc == Response.SC_OK) {
RpcCompleteEvent.fire(this);
callback.onFailure(new InvocationException("No JSON response"));
} else {
RpcCompleteEvent.fire(this);
callback.onFailure(new StatusCodeException(sc, rsp.getStatusText()));
}
}
protected static boolean isJsonBody(final Response rsp) {
String type = rsp.getHeader("Content-Type");
if (type == null) {
return false;
}
int semi = type.indexOf(';');
if (semi >= 0) {
type = type.substring(0, semi).trim();
}
return JsonConstants.JSONRPC20_ACCEPT_CTS.contains(type);
}
/**
* Call a JSON parser javascript function to parse an encoded JSON string.
*
* @param parser a javascript function
* @param json encoded JSON text
* @return the parsed data
* @see #jsonParser
*/
private static final native RpcResult parse(JavaScriptObject parserFunction,
String json)
/*-{
return parserFunction(json);
}-*/;
private static class RpcResult extends JavaScriptObject {
protected RpcResult() {
}
final native RpcError error()/*-{ return this.error; }-*/;
final native String xsrfKey()/*-{ return this.xsrfKey; }-*/;
}
private static class RpcError extends JavaScriptObject {
protected RpcError() {
}
final native String message()/*-{ return this.message; }-*/;
final native int code()/*-{ return this.code; }-*/;
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/v2_0/JsonCall20.java | Java | gpl3 | 4,635 |
// Copyright 2009 Gert Scholten
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.v2_0;
import org.rapla.rest.gwtjsonrpc.client.impl.AbstractJsonProxy;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import org.rapla.rest.gwtjsonrpc.common.JsonConstants;
import com.google.gwt.http.client.RequestBuilder;
/** JsonCall implementation for JsonRPC version 2.0 over HTTP POST */
public class JsonCall20HttpPost<T> extends JsonCall20<T> {
public JsonCall20HttpPost(AbstractJsonProxy abstractJsonProxy,
String methodName, String requestParams,
ResultDeserializer<T> resultDeserializer) {
super(abstractJsonProxy, methodName, requestParams, resultDeserializer);
}
@Override
protected void send() {
requestId = ++lastRequestId;
final StringBuilder body = new StringBuilder();
body.append("{\"jsonrpc\":\"2.0\",\"method\":\"");
body.append(methodName);
body.append("\",\"params\":");
body.append(requestParams);
body.append(",\"id\":").append(requestId);
body.append("}");
final RequestBuilder rb;
rb = new RequestBuilder(RequestBuilder.POST, proxy.getServiceEntryPoint());
rb.setHeader("Content-Type", JsonConstants.JSONRPC20_REQ_CT);
rb.setHeader("Accept", JsonConstants.JSONRPC20_ACCEPT_CTS);
rb.setCallback(this);
rb.setRequestData(body.toString());
send(rb);
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/v2_0/JsonCall20HttpPost.java | Java | gpl3 | 1,919 |
// Copyright 2009 Gert Scholten
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.v2_0;
import org.rapla.rest.gwtjsonrpc.client.impl.AbstractJsonProxy;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import org.rapla.rest.gwtjsonrpc.common.JsonConstants;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.URL;
/** JsonCall implementation for JsonRPC version 2.0 over HTTP POST */
public class JsonCall20HttpGet<T> extends JsonCall20<T> {
private String encodedRequestParams;
public JsonCall20HttpGet(AbstractJsonProxy abstractJsonProxy,
String methodName, String requestParams,
ResultDeserializer<T> resultDeserializer) {
super(abstractJsonProxy, methodName, requestParams, resultDeserializer);
encodedRequestParams = URL.encodeQueryString(encodeBase64(requestParams));
}
@Override
protected void send() {
requestId = ++lastRequestId;
final StringBuilder url = new StringBuilder(proxy.getServiceEntryPoint());
url.append("?jsonrpc=2.0&method=").append(methodName);
url.append("¶ms=").append(encodedRequestParams);
url.append("&id=").append(requestId);
final RequestBuilder rb;
rb = new RequestBuilder(RequestBuilder.GET, url.toString());
rb.setHeader("Content-Type", JsonConstants.JSONRPC20_REQ_CT);
rb.setHeader("Accept", JsonConstants.JSONRPC20_ACCEPT_CTS);
rb.setCallback(this);
send(rb);
}
/**
* Javascript base64 encoding implementation from.
*
* @see http://ecmanaut.googlecode.com/svn/trunk/lib/base64.js
*/
private static native String encodeBase64(String data)
/*-{
var out = "", c1, c2, c3, e1, e2, e3, e4;
for (var i = 0; i < data.length; ) {
c1 = data.charCodeAt(i++);
c2 = data.charCodeAt(i++);
c3 = data.charCodeAt(i++);
e1 = c1 >> 2;
e2 = ((c1 & 3) << 4) + (c2 >> 4);
e3 = ((c2 & 15) << 2) + (c3 >> 6);
e4 = c3 & 63;
if (isNaN(c2))
e3 = e4 = 64;
else if (isNaN(c3))
e4 = 64;
out += tab.charAt(e1) + tab.charAt(e2) + tab.charAt(e3) + tab.charAt(e4);
}
return out;
}-*/;
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/v2_0/JsonCall20HttpGet.java | Java | gpl3 | 2,688 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl;
import com.google.gwt.core.client.JavaScriptObject;
/**
* Base class for the {@link PrimitiveArrayResultDeserializer} and generated
* object array result deserializers.
*/
public abstract class ArrayResultDeserializer {
protected static native JavaScriptObject getResult(
JavaScriptObject responseObject)
/*-{
return responseObject.result;
}-*/;
protected static native int getResultSize(JavaScriptObject responseObject)
/*-{
return responseObject.result.length;
}-*/;
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ArrayResultDeserializer.java | Java | gpl3 | 1,135 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.user.client.rpc.InvocationException;
import com.google.gwt.user.client.rpc.RpcRequestBuilder;
import com.google.gwt.user.client.rpc.ServiceDefTarget;
/**
* Base class for generated RemoteJsonService implementations.
* <p>
* At runtime <code>GWT.create(Foo.class)</code> returns a subclass of this
* class, implementing the Foo and {@link ServiceDefTarget} interfaces.
*/
public abstract class AbstractJsonProxy implements ServiceDefTarget {
/** URL of the service implementation. */
String url;
private String token;
@Override
public String getServiceEntryPoint() {
return url;
}
@Override
public void setServiceEntryPoint(final String address) {
url = address;
}
@Override
public String getSerializationPolicyName() {
return "jsonrpc";
}
@Override
public void setRpcRequestBuilder(RpcRequestBuilder builder) {
if (builder != null)
throw new UnsupportedOperationException(
"A RemoteJsonService does not use the RpcRequestBuilder, so this method is unsupported.");
/**
* From the gwt docs:
*
* Calling this method with a null value will reset any custom behavior to
* the default implementation.
*
* If builder == null, we just ignore this invocation.
*/
}
protected <T> void doInvoke(final String methodName, final String reqData,
final ResultDeserializer<T> ser, final FutureResultImpl<T> cb)
throws InvocationException {
if (url == null) {
throw new NoServiceEntryPointSpecifiedException();
}
JsonCall<T> newJsonCall = newJsonCall(this, methodName, reqData, ser);
cb.setCall( newJsonCall);
if ( token != null )
{
newJsonCall.setToken( token );
}
}
protected abstract <T> JsonCall<T> newJsonCall(AbstractJsonProxy proxy,
final String methodName, final String reqData,
final ResultDeserializer<T> ser);
protected static native JavaScriptObject hostPageCacheGetOnce(String name)
/*-{ var r = $wnd[name];$wnd[name] = null;return r ? {result: r} : null; }-*/;
protected static native JavaScriptObject hostPageCacheGetMany(String name)
/*-{ return $wnd[name] ? {result : $wnd[name]} : null; }-*/;
public void setAuthThoken(String token) {
this.token = token;
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/AbstractJsonProxy.java | Java | gpl3 | 2,958 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import com.google.gwt.core.client.JavaScriptObject;
/** Base class for generated JsonSerializer implementations. */
public abstract class ObjectSerializer<T extends Object> extends
JsonSerializer<T> implements ResultDeserializer<T> {
@Override
public void printJson(final StringBuilder sb, final Object o) {
sb.append("{");
printJsonImpl(0, sb, o);
sb.append("}");
}
protected abstract int printJsonImpl(int field, StringBuilder sb, Object o);
@Override
public T fromResult(JavaScriptObject responseObject) {
final JavaScriptObject result = objectResult(responseObject);
return result == null ? null : fromJson(result);
}
static native JavaScriptObject objectResult(JavaScriptObject responseObject)
/*-{ return responseObject.result; }-*/;
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/ObjectSerializer.java | Java | gpl3 | 1,552 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import com.google.gwt.core.client.JavaScriptObject;
import java.util.ArrayList;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
/**
* Serialization for a {@link java.util.List}.
* <p>
* When deserialized from JSON the List implementation is always an
* {@link ArrayList}. When serializing to JSON any List is permitted.
*/
public class ListSerializer<T> extends JsonSerializer<java.util.List<T>>
implements ResultDeserializer<java.util.List<T>> {
private final JsonSerializer<T> serializer;
public ListSerializer(final JsonSerializer<T> s) {
serializer = s;
}
@Override
public void printJson(final StringBuilder sb, final java.util.List<T> o) {
sb.append('[');
boolean first = true;
for (final T item : o) {
if (first) {
first = false;
} else {
sb.append(',');
}
if (item != null) {
serializer.printJson(sb, item);
} else {
sb.append(JS_NULL);
}
}
sb.append(']');
}
@Override
public java.util.List<T> fromJson(final Object o) {
if (o == null) {
return null;
}
final JavaScriptObject jso = (JavaScriptObject) o;
final int n = size(jso);
final ArrayList<T> r = new ArrayList<T>(n);
for (int i = 0; i < n; i++) {
r.add(serializer.fromJson(get(jso, i)));
}
return r;
}
@Override
public java.util.List<T> fromResult(final JavaScriptObject response) {
final JavaScriptObject result = ObjectSerializer.objectResult(response);
return result == null ? null : fromJson(result);
}
private static final native int size(JavaScriptObject o)/*-{ return o.length; }-*/;
private static final native Object get(JavaScriptObject o, int i)/*-{ return o[i]; }-*/;
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/ListSerializer.java | Java | gpl3 | 2,451 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import org.rapla.rest.gwtjsonrpc.common.VoidResult;
import com.google.gwt.core.client.JavaScriptObject;
public class VoidResult_JsonSerializer extends JsonSerializer<VoidResult>
implements ResultDeserializer<VoidResult> {
public static final VoidResult_JsonSerializer INSTANCE =
new VoidResult_JsonSerializer();
private VoidResult_JsonSerializer() {
}
@Override
public void printJson(final StringBuilder sb, final VoidResult o) {
sb.append("{}");
}
@Override
public VoidResult fromJson(final Object o) {
return VoidResult.INSTANCE;
}
@Override
public VoidResult fromResult(JavaScriptObject responseObject) {
return VoidResult.INSTANCE;
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/VoidResult_JsonSerializer.java | Java | gpl3 | 1,455 |
// Copyright 2009 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import com.google.gwt.core.client.JavaScriptObject;
public class PrimitiveResultDeserializers {
static native boolean booleanResult(JavaScriptObject responseObject)
/*-{
return responseObject.result;
}-*/;
static native byte byteResult(JavaScriptObject responseObject)
/*-{
return responseObject.result;
}-*/;
static native String stringResult(JavaScriptObject responseObject)
/*-{
return responseObject.result;
}-*/;
static char charResult(JavaScriptObject responseObject) {
return JsonSerializer.toChar(stringResult(responseObject));
}
static native double doubleResult(JavaScriptObject responseObject)
/*-{
return responseObject.result;
}-*/;
static native float floatResult(JavaScriptObject responseObject)
/*-{
return responseObject.result;
}-*/;
static native int intResult(JavaScriptObject responseObject)
/*-{
return responseObject.result;
}-*/;
static native short shortResult(JavaScriptObject responseObject)
/*-{
return responseObject.result;
}-*/;
public static final ResultDeserializer<Boolean> BOOLEAN_INSTANCE =
new ResultDeserializer<Boolean>() {
@Override
public Boolean fromResult(JavaScriptObject responseObject) {
return booleanResult(responseObject);
}
};
public static final ResultDeserializer<Byte> BYTE_INSTANCE =
new ResultDeserializer<Byte>() {
@Override
public Byte fromResult(JavaScriptObject responseObject) {
return byteResult(responseObject);
}
};
public static final ResultDeserializer<Character> CHARACTER_INSTANCE =
new ResultDeserializer<Character>() {
@Override
public Character fromResult(JavaScriptObject responseObject) {
return charResult(responseObject);
}
};
public static final ResultDeserializer<Double> DOUBLE_INSTANCE =
new ResultDeserializer<Double>() {
@Override
public Double fromResult(JavaScriptObject responseObject) {
return doubleResult(responseObject);
}
};
public static final ResultDeserializer<Float> FLOAT_INSTANCE =
new ResultDeserializer<Float>() {
@Override
public Float fromResult(JavaScriptObject responseObject) {
return floatResult(responseObject);
}
};
public static final ResultDeserializer<Integer> INTEGER_INSTANCE =
new ResultDeserializer<Integer>() {
@Override
public Integer fromResult(JavaScriptObject responseObject) {
return intResult(responseObject);
}
};
public static final ResultDeserializer<Short> SHORT_INSTANCE =
new ResultDeserializer<Short>() {
@Override
public Short fromResult(JavaScriptObject responseObject) {
return shortResult(responseObject);
}
};
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/PrimitiveResultDeserializers.java | Java | gpl3 | 3,629 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import com.google.gwt.core.client.JavaScriptObject;
/**
* Serialization for a {@link java.util.Map} using any Object key.
* <p>
* The JSON format is an array with even length, alternating key and value
* elements. For example: <code>[k1, v1, k2, v2, k3, v3, ...]</code>. The keys
* and values may be any Object type.
* <p>
* When deserialized from JSON the Map implementation is always a
* {@link HashMap}. When serializing to JSON any Map is permitted.
*/
public class ObjectMapSerializer<K, V> extends
JsonSerializer<java.util.Map<K, V>> implements
ResultDeserializer<java.util.Map<K, V>> {
private final JsonSerializer<K> keySerializer;
private final JsonSerializer<V> valueSerializer;
public ObjectMapSerializer(final JsonSerializer<K> k,
final JsonSerializer<V> v) {
keySerializer = k;
valueSerializer = v;
}
@Override
public void printJson(final StringBuilder sb, final java.util.Map<K, V> o) {
sb.append('[');
boolean first = true;
for (final Map.Entry<K, V> e : o.entrySet()) {
if (first) {
first = false;
} else {
sb.append(',');
}
encode(sb, keySerializer, e.getKey());
sb.append(',');
encode(sb, valueSerializer, e.getValue());
}
sb.append(']');
}
private static <T> void encode(final StringBuilder sb,
final JsonSerializer<T> serializer, final T item) {
if (item != null) {
serializer.printJson(sb, item);
} else {
sb.append(JS_NULL);
}
}
@Override
public java.util.Map<K, V> fromJson(final Object o) {
if (o == null) {
return null;
}
final JavaScriptObject jso = (JavaScriptObject) o;
final int n = size(jso);
final HashMap<K, V> r = new LinkedHashMap<K, V>();
for (int i = 0; i < n;) {
final K k = keySerializer.fromJson(get(jso, i++));
final V v = valueSerializer.fromJson(get(jso, i++));
r.put(k, v);
}
return r;
}
@Override
public java.util.Map<K, V> fromResult(final JavaScriptObject response) {
final JavaScriptObject result = ObjectSerializer.objectResult(response);
return result == null ? null : fromJson(result);
}
private static final native int size(JavaScriptObject o)/*-{ return o.length; }-*/;
private static final native Object get(JavaScriptObject o, int i)/*-{ return o[i]; }-*/;
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/ObjectMapSerializer.java | Java | gpl3 | 3,198 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import com.google.gwt.core.client.JavaScriptObject;
/**
* Default serialization for any Object[] sort of type.
* <p>
* Primitive array types (like <code>int[]</code>) are not supported.
*/
public class ObjectArraySerializer<T> {
private final JsonSerializer<T> serializer;
public ObjectArraySerializer(final JsonSerializer<T> s) {
serializer = s;
}
public void printJson(final StringBuilder sb, final T[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
final T v = o[i];
if (v != null) {
serializer.printJson(sb, v);
} else {
sb.append(JsonSerializer.JS_NULL);
}
}
sb.append(']');
}
public void fromJson(final JavaScriptObject jso, final T[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = serializer.fromJson(get(jso, i));
}
}
public static native int size(JavaScriptObject o)/*-{ return o.length; }-*/;
private static final native Object get(JavaScriptObject o, int i)/*-{ return o[i]; }-*/;
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/ObjectArraySerializer.java | Java | gpl3 | 1,766 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.JsonUtils;
/** Default serialization for a String. */
public final class JavaLangString_JsonSerializer extends
JsonSerializer<java.lang.String> implements
ResultDeserializer<java.lang.String> {
public static final JavaLangString_JsonSerializer INSTANCE =
new JavaLangString_JsonSerializer();
@Override
public java.lang.String fromJson(final Object o) {
return (String) o;
}
@Override
public void printJson(final StringBuilder sb, final java.lang.String o) {
sb.append(JsonUtils.escapeValue(o));
}
@Override
public String fromResult(JavaScriptObject responseObject) {
return PrimitiveResultDeserializers.stringResult(responseObject);
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/JavaLangString_JsonSerializer.java | Java | gpl3 | 1,537 |
// Copyright 2009 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import org.rapla.rest.gwtjsonrpc.client.impl.ArrayResultDeserializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import com.google.gwt.core.client.JavaScriptObject;
public class PrimitiveArrayResultDeserializers extends ArrayResultDeserializer {
public static ResultDeserializer<Boolean[]> BOOLEAN_INSTANCE =
new ResultDeserializer<Boolean[]>() {
@Override
public Boolean[] fromResult(JavaScriptObject responseObject) {
final Boolean[] tmp = new Boolean[getResultSize(responseObject)];
PrimitiveArraySerializer.INSTANCE.fromJson(getResult(responseObject),
tmp);
return tmp;
}
};
public static ResultDeserializer<Byte[]> BYTE_INSTANCE =
new ResultDeserializer<Byte[]>() {
@Override
public Byte[] fromResult(JavaScriptObject responseObject) {
final Byte[] tmp = new Byte[getResultSize(responseObject)];
PrimitiveArraySerializer.INSTANCE.fromJson(getResult(responseObject),
tmp);
return tmp;
}
};
public static ResultDeserializer<Character[]> CHARACTER_INSTANCE =
new ResultDeserializer<Character[]>() {
@Override
public Character[] fromResult(JavaScriptObject responseObject) {
final Character[] tmp = new Character[getResultSize(responseObject)];
PrimitiveArraySerializer.INSTANCE.fromJson(getResult(responseObject),
tmp);
return tmp;
}
};
public static ResultDeserializer<Double[]> DOUBLE_INSTANCE =
new ResultDeserializer<Double[]>() {
@Override
public Double[] fromResult(JavaScriptObject responseObject) {
final Double[] tmp = new Double[getResultSize(responseObject)];
PrimitiveArraySerializer.INSTANCE.fromJson(getResult(responseObject),
tmp);
return tmp;
}
};
public static ResultDeserializer<Float[]> FLOAT_INSTANCE =
new ResultDeserializer<Float[]>() {
@Override
public Float[] fromResult(JavaScriptObject responseObject) {
final Float[] tmp = new Float[getResultSize(responseObject)];
PrimitiveArraySerializer.INSTANCE.fromJson(getResult(responseObject),
tmp);
return tmp;
}
};
public static ResultDeserializer<Integer[]> INTEGER_INSTANCE =
new ResultDeserializer<Integer[]>() {
@Override
public Integer[] fromResult(JavaScriptObject responseObject) {
final Integer[] tmp = new Integer[getResultSize(responseObject)];
PrimitiveArraySerializer.INSTANCE.fromJson(getResult(responseObject),
tmp);
return tmp;
}
};
public static ResultDeserializer<Short[]> SHORT_INSTANCE =
new ResultDeserializer<Short[]>() {
@Override
public Short[] fromResult(JavaScriptObject responseObject) {
final Short[] tmp = new Short[getResultSize(responseObject)];
PrimitiveArraySerializer.INSTANCE.fromJson(getResult(responseObject),
tmp);
return tmp;
}
};
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/PrimitiveArrayResultDeserializers.java | Java | gpl3 | 3,778 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import com.google.gwt.core.client.JavaScriptObject;
import java.util.HashSet;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
/**
* Serialization for a {@link java.util.Set}.
* <p>
* When deserialized from JSON the Set implementation is always a
* {@link HashSet}. When serializing to JSON any Set is permitted.
*/
public class SetSerializer<T> extends JsonSerializer<java.util.Set<T>>
implements ResultDeserializer<java.util.Set<T>> {
private final JsonSerializer<T> serializer;
public SetSerializer(final JsonSerializer<T> s) {
serializer = s;
}
@Override
public void printJson(final StringBuilder sb, final java.util.Set<T> o) {
sb.append('[');
boolean first = true;
for (final T item : o) {
if (first) {
first = false;
} else {
sb.append(',');
}
if (item != null) {
serializer.printJson(sb, item);
} else {
sb.append(JS_NULL);
}
}
sb.append(']');
}
@Override
public java.util.Set<T> fromJson(final Object o) {
if (o == null) {
return null;
}
final JavaScriptObject jso = (JavaScriptObject) o;
final int n = size(jso);
final HashSet<T> r = new HashSet<T>(n);
for (int i = 0; i < n; i++) {
r.add(serializer.fromJson(get(jso, i)));
}
return r;
}
@Override
public java.util.Set<T> fromResult(final JavaScriptObject response) {
final JavaScriptObject result = ObjectSerializer.objectResult(response);
return result == null ? null : fromJson(result);
}
private static final native int size(JavaScriptObject o)/*-{ return o.length; }-*/;
private static final native Object get(JavaScriptObject o, int i)/*-{ return o[i]; }-*/;
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/SetSerializer.java | Java | gpl3 | 2,432 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import java.util.Date;
import org.rapla.components.util.ParseDateException;
import org.rapla.components.util.SerializableDateTimeFormat;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import com.google.gwt.core.client.JavaScriptObject;
/** Default serialization for a {@link java.util.Date}. */
public final class JavaUtilDate_JsonSerializer extends
JsonSerializer<java.util.Date> implements
ResultDeserializer<java.util.Date> {
public static final JavaUtilDate_JsonSerializer INSTANCE =
new JavaUtilDate_JsonSerializer();
@Override
public java.util.Date fromJson(final Object o) {
if (o != null) {
Date date;
try {
date = SerializableDateTimeFormat.INSTANCE.parseTimestamp((String)o);
} catch (ParseDateException e) {
throw new IllegalArgumentException("Invalid date format: " + o);
}
return date;
}
return null;
}
@Override
public void printJson(final StringBuilder sb, final java.util.Date o) {
sb.append('"');
String string = SerializableDateTimeFormat.INSTANCE.formatTimestamp( o);
sb.append(string);
sb.append('"');
}
@Override
public Date fromResult(JavaScriptObject responseObject) {
return fromJson(PrimitiveResultDeserializers.stringResult(responseObject));
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/JavaUtilDate_JsonSerializer.java | Java | gpl3 | 1,984 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
/** Base serializer for Enum types. */
public abstract class EnumSerializer<T extends Enum<?>> extends
JsonSerializer<T> {
@Override
public void printJson(final StringBuilder sb, final T o) {
sb.append('"');
sb.append(o.name());
sb.append('"');
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/EnumSerializer.java | Java | gpl3 | 970 |
// Copyright 2009 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.JsonUtils;
public class PrimitiveArraySerializer {
public static final PrimitiveArraySerializer INSTANCE =
new PrimitiveArraySerializer();
private void printJsonWithToString(final StringBuilder sb, final Object[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(o[i] != null ? o[i].toString() : JsonSerializer.JS_NULL);
}
sb.append(']');
}
// Serialisation of Boxed Primitives
public void printJson(final StringBuilder sb, final Boolean[] o) {
printJsonWithToString(sb, o);
}
public void printJson(final StringBuilder sb, final Byte[] o) {
printJsonWithToString(sb, o);
}
public void printJson(final StringBuilder sb, final Character[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
if (o[i] != null) {
sb.append(JsonUtils.escapeValue(String.valueOf(o[i])));
} else
sb.append(JsonSerializer.JS_NULL);
}
sb.append(']');
}
public void printJson(final StringBuilder sb, final Double[] o) {
printJsonWithToString(sb, o);
}
public void printJson(final StringBuilder sb, final Float[] o) {
printJsonWithToString(sb, o);
}
public void printJson(final StringBuilder sb, final Integer[] o) {
printJsonWithToString(sb, o);
}
public void printJson(final StringBuilder sb, final Short[] o) {
printJsonWithToString(sb, o);
}
// Serialisation of Primitives
public void printJson(final StringBuilder sb, final boolean[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(o[i]);
}
sb.append(']');
}
public void printJson(final StringBuilder sb, final byte[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(o[i]);
}
sb.append(']');
}
public void printJson(final StringBuilder sb, final char[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(o[i]);
}
sb.append(']');
}
public void printJson(final StringBuilder sb, final double[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(o[i]);
}
sb.append(']');
}
public void printJson(final StringBuilder sb, final float[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(o[i]);
}
sb.append(']');
}
public void printJson(final StringBuilder sb, final int[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(o[i]);
}
sb.append(']');
}
public void printJson(final StringBuilder sb, final short[] o) {
sb.append('[');
for (int i = 0, n = o.length; i < n; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(o[i]);
}
sb.append(']');
}
// DeSerialisation native getters
private static final native boolean getBoolean(JavaScriptObject jso, int pos)
/*-{ return jso[pos]; }-*/;
private static final native byte getByte(JavaScriptObject jso, int pos)
/*-{ return jso[pos]; }-*/;
private static final native String getString(JavaScriptObject jso, int pos)
/*-{ return jso[pos]; }-*/;
private static final native double getDouble(JavaScriptObject jso, int pos)
/*-{ return jso[pos]; }-*/;
private static final native float getFloat(JavaScriptObject jso, int pos)
/*-{ return jso[pos]; }-*/;
private static final native int getInteger(JavaScriptObject jso, int pos)
/*-{ return jso[pos]; }-*/;
private static final native short getShort(JavaScriptObject jso, int pos)
/*-{ return jso[pos]; }-*/;
// DeSerialisation of boxed primitive arrays
public void fromJson(final JavaScriptObject jso, final Boolean[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getBoolean(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final Byte[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getByte(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final Character[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = JsonSerializer.toChar(getString(jso, i));
}
}
public void fromJson(final JavaScriptObject jso, final Double[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getDouble(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final Float[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getFloat(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final Integer[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getInteger(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final Short[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getShort(jso, i);
}
}
// DeSerialisation of primitive arrays
public void fromJson(final JavaScriptObject jso, final boolean[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getBoolean(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final byte[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getByte(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final char[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = JsonSerializer.toChar(getString(jso, i));
}
}
public void fromJson(final JavaScriptObject jso, final double[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getDouble(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final float[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getFloat(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final int[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getInteger(jso, i);
}
}
public void fromJson(final JavaScriptObject jso, final short[] r) {
for (int i = 0; i < r.length; i++) {
r[i] = getShort(jso, i);
}
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/PrimitiveArraySerializer.java | Java | gpl3 | 7,082 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl.ser;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.JsonUtils;
/**
* Serialization for a {@link java.util.Map} using only String keys.
* <p>
* The JSON representation is a JSON object, the map keys become the property
* names of the JSON object and the map values are the property values.
* <p>
* When deserialized from JSON the Map implementation is always a
* {@link HashMap}. When serializing to JSON any Map is permitted.
*/
public class StringMapSerializer<V> extends
JsonSerializer<java.util.Map<String, V>> implements
ResultDeserializer<java.util.Map<String, V>> {
private final JsonSerializer<V> valueSerializer;
public StringMapSerializer(final JsonSerializer<V> v) {
valueSerializer = v;
}
@Override
public void printJson(final StringBuilder sb, final java.util.Map<String, V> o) {
sb.append('{');
boolean first = true;
for (final Map.Entry<String, V> e : o.entrySet()) {
if (first) {
first = false;
} else {
sb.append(',');
}
sb.append(JsonUtils.escapeValue(e.getKey()));
sb.append(':');
encode(sb, valueSerializer, e.getValue());
}
sb.append('}');
}
private static <T> void encode(final StringBuilder sb,
final JsonSerializer<T> serializer, final T item) {
if (item != null) {
serializer.printJson(sb, item);
} else {
sb.append(JS_NULL);
}
}
@Override
public java.util.Map<String, V> fromJson(final Object o) {
if (o == null) {
return null;
}
final JavaScriptObject jso = (JavaScriptObject) o;
final Map<String, V> r = new LinkedHashMap<String, V>();
copy(r, jso);
return r;
}
@Override
public java.util.Map<String, V> fromResult(final JavaScriptObject response) {
final JavaScriptObject result = ObjectSerializer.objectResult(response);
return result == null ? null : fromJson(result);
}
private native void copy(Map<String, V> r, JavaScriptObject jsObject)
/*-{
for (var key in jsObject) {
this.@org.rapla.rest.gwtjsonrpc.client.impl.ser.StringMapSerializer::copyOne(Ljava/util/Map;Ljava/lang/String;Ljava/lang/Object;)(r, key, jsObject[key]);
}
}-*/;
void copyOne(final Map<String, V> r, final String k, final Object o) {
r.put(k, valueSerializer.fromJson(o));
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ser/StringMapSerializer.java | Java | gpl3 | 3,184 |
package org.rapla.rest.gwtjsonrpc.client.impl;
import org.rapla.rest.gwtjsonrpc.common.AsyncCallback;
import org.rapla.rest.gwtjsonrpc.common.FutureResult;
public class FutureResultImpl<T> implements FutureResult<T> {
JsonCall call;
public T get() throws Exception
{
throw new UnsupportedOperationException();
}
public T get(long wait) throws Exception
{
throw new UnsupportedOperationException();
}
@SuppressWarnings("unchecked")
public void get(AsyncCallback<T> callback)
{
call.send(callback);
}
public void setCall( JsonCall call)
{
this.call = call;
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/FutureResultImpl.java | Java | gpl3 | 593 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl;
import com.google.gwt.core.client.JsonUtils;
/**
* Converter between JSON and Java object representations.
* <p>
* Implementors must provide bidirectional conversion, typically using the GWT
* JavaScriptObject and native JavaScript magic to read the JSON data structure.
* <p>
* Most implementations are generated automatically at compile-time by the
* <code>RemoteJsonServiceProxyGenerator</code>.
*
* @param <T> type of Java class this type works on.
*/
public abstract class JsonSerializer<T> {
/** Magic constant in JSON to mean the same as Java null. */
public static final String JS_NULL = "null";
/**
* Convert a Java object to JSON text.
* <p>
* Implementations should recursively call any nested object or collection at
* the appropriate time to append the nested item's JSON text.
*
* @param sb the output string buffer the JSON text should be appended onto
* the end of.
* @param o the Java instance being converted. Never null.
*/
public abstract void printJson(StringBuilder sb, T o);
/**
* Convert from JSON (stored as a JavaScriptObject) into a new Java instance.
*
* @param o the JSON object instance; typically this should be downcast to
* JavaScriptObject. May be null, in which case null should be returned
* instead of an instance.
* @return null if <code>o</code> was null; otherwise the new object instance
* with the data copied over form the JSON representation.
*/
public abstract T fromJson(Object o);
/**
* Utility function to convert a String to safe JSON text.
* <p>
* For example, if <code>val = "b\nb"</code> this method returns the value
* <code>"\"b\\nb\""</code>.
* <p>
* Typically called by {@link #printJson(StringBuilder, Object)}, or through
* {@link JavaLangString_JsonSerializer}.
*
* @param val string text requiring escaping support. Must not be null.
* @return a JSON literal text value, surrounded with double quotes.
* @deprecated Use {@link JsonUtils#escapeValue(String)}
*/
@Deprecated
public static final String escapeString(String val) {
return JsonUtils.escapeValue(val);
}
/**
* Escape a single character, without double quotes surrounding it.
*
* @deprecated implementation depends on private method hack. Do not use.
*/
@Deprecated
public static final String escapeChar(final char c) {
return escapeCharImpl(String.valueOf(c));
}
@Deprecated
private static final native String escapeCharImpl(String c) /*-{ return @com.google.gwt.core.client.JsonUtils::escapeChar(Ljava/lang/String;)(c); }-*/;
/** Return the first character of a string, or '\0' if the string is empty. */
public static final char toChar(final String val) {
return val.length() > 0 ? val.charAt(0) : '\0';
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/JsonSerializer.java | Java | gpl3 | 3,463 |
// Copyright 2009 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client.impl;
import com.google.gwt.core.client.JavaScriptObject;
/**
* Inteface class for deserializers of results from JSON RPC calls. Since
* primitive and array results need to be handled specially, not all results can
* be deserialized using the standard object serializers.
*
* @param <T> the result type of an RPC call.
*/
public interface ResultDeserializer<T> {
public T fromResult(JavaScriptObject responseObject);
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/impl/ResultDeserializer.java | Java | gpl3 | 1,056 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import org.rapla.rest.gwtjsonrpc.common.AsyncCallback;
import com.google.gwt.core.client.JavaScriptObject;
/**
* Global JavaScript function for JSON callbacks from non-RPC invocations.
* <p>
* To setup a callback declare one in your remote service interface:
*
* <pre>
* public interface MyActions extends RemoteJsonService {
* CallbackHandle<MyResult> forMyResult(AsyncCallback<MyResult> ac);
* }
* </pre>
* <p>
* Then in your application code create the callback handle and obtain its
* function name. Pass the function name to the remote service, so the remote
* service can execute:
*
* <pre>
* $functionName($result)
* </pre>
* <p>
* where <code>$functionName</code> came from {@link #getFunctionName()} (you
* may need to prefix <code>"parent."</code> if invoking within an iframe) and
* <code>$result</code> is the native JSON encoding of the <code>MyResult</code>
* object type.
* <p>
* When the callback is complete it will be automatically unregistered from the
* window and your {@link AsyncCallback}'s <code>onSuccess</code> will be called
* with the deserialized <code>MyResult</code> instance.
* <p>
* Each CallbackHandle uses a unique function name, permitting the application
* to use multiple concurrent callbacks. Handles which are canceled before the
* response is received will never be invoked.
*/
public class CallbackHandle<R> {
private static int callbackId;
static {
nativeInit();
}
private static int nextFunction() {
return ++callbackId;
}
private final ResultDeserializer<R> deserializer;
private final AsyncCallback<R> callback;
private int functionId;
/**
* Create a new callback instance.
* <p>
* Typically this should be done by a factory function inside of a
* RemoteJsonService interface.
*
* @param ser parses the JSON result once received back.
* @param ac the application callback function to supply the result to. Only
* <code>onSuccess</code> will be invoked.
*/
public CallbackHandle(final ResultDeserializer<R> ser,
final AsyncCallback<R> ac) {
deserializer = ser;
callback = ac;
}
/**
* Install this handle into the browser window and generate a unique name.
* <p>
* Does nothing if the callback has already been installed.
* <p>
* This method pins this callback object and the application supplied
* {@link AsyncCallback} into the global browser memory, so it exists when the
* JSON service returns with its result data. If the JSON service never
* returns, the callback (and anything it reaches) may leak. Applications can
* use {@link #cancel()} to explicitly remove this handle.
*/
public void install() {
if (functionId == 0) {
functionId = nextFunction();
nativeInstall(functionId, this);
}
}
/**
* Obtain the unique function name for this JSON callback.
* <p>
* Applications must call {@link #install()} first to ensure the function name
* has been generated and installed into the window. The function name is only
* valid until either {@link #cancel()} is called or the remote service has
* returned the call.
*
* @return name of the function the JSON service should call with the
* resulting data.
*/
public String getFunctionName() {
assert functionId > 0;
return "__gwtjsonrpc_callbackhandle[" + functionId + "]";
}
/**
* Delete this function from the browser so it can't be called.
* <p>
* Does nothing if the callback has already been canceled.
* <p>
* This method deletes the function, permitting <code>this</code> and the
* application callback to be garbage collected. Automatically invoked when a
* result is received.
*/
public void cancel() {
if (functionId > 0) {
nativeDelete(functionId);
functionId = 0;
}
}
final void onResult(final JavaScriptObject rpcResult) {
cancel();
JsonUtil.invoke(deserializer, callback, rpcResult);
}
private static final native void nativeInit()
/*-{ $wnd.__gwtjsonrpc_callbackhandle = new Array(); }-*/;
private static final native void nativeDelete(int funid)
/*-{ delete $wnd.__gwtjsonrpc_callbackhandle[funid]; }-*/;
private static final native void nativeInstall(int funid,
CallbackHandle<?> imp)
/*-{ $wnd.__gwtjsonrpc_callbackhandle[funid] = function(r) { imp.@org.rapla.rest.gwtjsonrpc.client.CallbackHandle::onResult(Lcom/google/gwt/core/client/JavaScriptObject;)({result:r}); }; }-*/;
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/CallbackHandle.java | Java | gpl3 | 5,211 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client;
import org.rapla.rest.gwtjsonrpc.client.event.BaseRpcEvent;
import org.rapla.rest.gwtjsonrpc.client.event.RpcCompleteEvent;
import org.rapla.rest.gwtjsonrpc.client.event.RpcCompleteHandler;
import org.rapla.rest.gwtjsonrpc.client.event.RpcStartEvent;
import org.rapla.rest.gwtjsonrpc.client.event.RpcStartHandler;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import org.rapla.rest.gwtjsonrpc.common.AsyncCallback;
import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.event.shared.HandlerManager;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.rpc.InvocationException;
import com.google.gwt.user.client.rpc.ServiceDefTarget;
/** Client side utility functions. */
public class JsonUtil {
private static final HandlerManager globalHandlers = new HandlerManager(null);
/**
* Bind a RemoteJsonService proxy to its server URL.
*
* @param <T> type of the service interface.
* @param imp the service instance, returned by <code>GWT.create</code>.
* @param path the path of the service, relative to the GWT module.
* @return always <code>imp</code>.
* @see com.google.gwt.user.client.rpc.RemoteServiceRelativePath
*/
public static <T> T bind(final T imp,
final String path) {
assert GWT.isClient();
assert imp instanceof ServiceDefTarget;
final String base = GWT.getModuleBaseURL();
((ServiceDefTarget) imp).setServiceEntryPoint(base + path);
return imp;
}
/** Register a handler for RPC start events. */
public static HandlerRegistration addRpcStartHandler(RpcStartHandler h) {
return globalHandlers.addHandler(RpcStartEvent.getType(), h);
}
/** Register a handler for RPC completion events. */
public static HandlerRegistration addRpcCompleteHandler(RpcCompleteHandler h) {
return globalHandlers.addHandler(RpcCompleteEvent.getType(), h);
}
public static void fireEvent(BaseRpcEvent<?> event) {
globalHandlers.fireEvent(event);
}
public static <T> void invoke(final ResultDeserializer<T> resultDeserializer,
final AsyncCallback<T> callback, final JavaScriptObject rpcResult) {
final T result;
try {
result = resultDeserializer.fromResult(rpcResult);
} catch (RuntimeException e) {
callback.onFailure(new InvocationException("Invalid JSON Response", e));
return;
}
callback.onSuccess(result);
}
private JsonUtil() {
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/JsonUtil.java | Java | gpl3 | 3,109 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.client;
import com.google.gwt.json.client.JSONValue;
/**
* Exception given to
* {@link org.rapla.rest.gwtjsonrpc.common.AsyncCallback#onFailure(Throwable)}.
* <p>
* This exception is used if the remote JSON server has returned a well-formed
* JSON error response.
*/
public class RemoteJsonException extends Exception {
private static final long serialVersionUID = 1L;
private int code;
private JSONValue data;
/**
* Construct a new exception representing a well formed JSON error response.
*
* @param message A String value that provides a short description of the
* error
* @param code A number that indicates the actual error that occurred
* @param data A JSON value instance that carries custom and
* application-specific error information
*/
public RemoteJsonException(final String message, int code, JSONValue data) {
super(message);
this.code = code;
this.data = data;
}
/**
* Creates a new RemoteJsonException with code 999 and no data.
*
* @param message A String value that provides a short description of the
* error
*/
public RemoteJsonException(final String message) {
this(message, 999, null);
}
/**
* Gets the error code.
* <p>
* Note that the JSON-RPC 1.1 draf does not define error codes yet.
*
* @return A number that indicates the actual error that occurred.
*/
public int getCode() {
return code;
}
/**
* Same as getData.
*
* @return the error data, or <code>null</code> if none was specified
* @see #getData
*/
public JSONValue getError() {
return data;
}
/**
* Gets the extra error information supplied by the service.
*
* @return the error data, or <code>null</code> if none was specified
*/
public JSONValue getData() {
return data;
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/client/RemoteJsonException.java | Java | gpl3 | 2,462 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.rebind;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.EnumSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.JavaLangString_JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.JavaUtilDate_JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.ListSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.ObjectArraySerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.ObjectMapSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.ObjectSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.PrimitiveArraySerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.SetSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.StringMapSerializer;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JPackage;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;
class SerializerCreator {
private static final String SER_SUFFIX = "_JsonSerializer";
private static final Comparator<JField> FIELD_COMP =
new Comparator<JField>() {
@Override
public int compare(final JField o1, final JField o2) {
return o1.getName().compareTo(o2.getName());
}
};
private static final HashMap<String, String> defaultSerializers;
private static final HashMap<String, String> parameterizedSerializers;
static {
defaultSerializers = new HashMap<String, String>();
parameterizedSerializers = new HashMap<String, String>();
defaultSerializers.put(java.lang.String.class.getCanonicalName(),
JavaLangString_JsonSerializer.class.getCanonicalName());
defaultSerializers.put(java.util.Date.class.getCanonicalName(),
JavaUtilDate_JsonSerializer.class.getCanonicalName());
// defaultSerializers.put(java.sql.Date.class.getCanonicalName(),
// JavaSqlDate_JsonSerializer.class.getCanonicalName());
// defaultSerializers.put(java.sql.Timestamp.class.getCanonicalName(),
// JavaSqlTimestamp_JsonSerializer.class.getCanonicalName());
parameterizedSerializers.put(java.util.List.class.getCanonicalName(),
ListSerializer.class.getCanonicalName());
parameterizedSerializers.put(java.util.Map.class.getCanonicalName(),
ObjectMapSerializer.class.getCanonicalName());
parameterizedSerializers.put(java.util.Set.class.getCanonicalName(),
SetSerializer.class.getCanonicalName());
}
private final HashMap<String, String> generatedSerializers;
private final GeneratorContext context;
private JClassType targetType;
SerializerCreator(final GeneratorContext c) {
context = c;
generatedSerializers = new HashMap<String, String>();
}
String create(final JClassType targetType, final TreeLogger logger)
throws UnableToCompleteException {
if (targetType.isParameterized() != null || targetType.isArray() != null) {
ensureSerializersForTypeParameters(logger, targetType);
}
String sClassName = serializerFor(targetType);
if (sClassName != null) {
return sClassName;
}
checkCanSerialize(logger, targetType, true);
recursivelyCreateSerializers(logger, targetType);
this.targetType = targetType;
final SourceWriter srcWriter = getSourceWriter(logger, context);
final String sn = getSerializerQualifiedName(targetType);
if (!generatedSerializers.containsKey(targetType.getQualifiedSourceName())) {
generatedSerializers.put(targetType.getQualifiedSourceName(), sn);
}
if (srcWriter == null) {
return sn;
}
if (!targetType.isAbstract()) {
generateSingleton(srcWriter);
}
if (targetType.isEnum() != null) {
generateEnumFromJson(srcWriter);
} else {
generateInstanceMembers(srcWriter);
generatePrintJson(srcWriter);
generateFromJson(srcWriter);
generateGetSets(srcWriter);
}
srcWriter.commit(logger);
return sn;
}
private void recursivelyCreateSerializers(final TreeLogger logger,
final JType targetType) throws UnableToCompleteException {
if (targetType.isPrimitive() != null || isBoxedPrimitive(targetType)) {
return;
}
final JClassType targetClass = targetType.isClass();
if (needsSuperSerializer(targetClass)) {
create(targetClass.getSuperclass(), logger);
}
for (final JField f : sortFields(targetClass)) {
ensureSerializer(logger, f.getType());
}
}
Set<JClassType> createdType = new HashSet<JClassType>();
private void ensureSerializer(final TreeLogger logger, final JType type)
throws UnableToCompleteException {
if (ensureSerializersForTypeParameters(logger, type)) {
return;
}
final String qsn = type.getQualifiedSourceName();
if (defaultSerializers.containsKey(qsn)
|| parameterizedSerializers.containsKey(qsn)) {
return;
}
JClassType type2 = (JClassType) type;
if ( createdType.contains( type2))
{
return;
}
createdType.add( type2 );
create(type2, logger);
}
private boolean ensureSerializersForTypeParameters(final TreeLogger logger,
final JType type) throws UnableToCompleteException {
if (isJsonPrimitive(type) || isBoxedPrimitive(type)) {
return true;
}
if (type.isArray() != null) {
ensureSerializer(logger, type.isArray().getComponentType());
return true;
}
if (type.isParameterized() != null) {
for (final JClassType t : type.isParameterized().getTypeArgs()) {
ensureSerializer(logger, t);
}
}
return false;
}
void checkCanSerialize(final TreeLogger logger, final JType type)
throws UnableToCompleteException {
checkCanSerialize(logger, type, false);
}
Set<JClassType> checkedType = new HashSet<JClassType>();
void checkCanSerialize(final TreeLogger logger, final JType type,
boolean allowAbstractType) throws UnableToCompleteException {
if (type.isPrimitive() == JPrimitiveType.LONG) {
logger.log(TreeLogger.ERROR,
"Type 'long' not supported in JSON encoding", null);
throw new UnableToCompleteException();
}
// if (type.isPrimitive() == JPrimitiveType.VOID) {
// logger.log(TreeLogger.ERROR,
// "Type 'void' not supported in JSON encoding", null);
// throw new UnableToCompleteException();
// }
final String qsn = type.getQualifiedSourceName();
if (type.isEnum() != null) {
return;
}
if (isJsonPrimitive(type) || isBoxedPrimitive(type)) {
return;
}
if (type.isArray() != null) {
final JType leafType = type.isArray().getLeafType();
if (leafType.isPrimitive() != null || isBoxedPrimitive(leafType)) {
if (type.isArray().getRank() != 1) {
logger.log(TreeLogger.ERROR, "gwtjsonrpc does not support "
+ "(de)serializing of multi-dimensional arrays of primitves");
// To work around this, we would need to generate serializers for
// them, this can be considered a todo
throw new UnableToCompleteException();
} else
// Rank 1 arrays work fine.
return;
}
checkCanSerialize(logger, type.isArray().getComponentType());
return;
}
if (defaultSerializers.containsKey(qsn)) {
return;
}
if (type.isParameterized() != null) {
final JClassType[] typeArgs = type.isParameterized().getTypeArgs();
for (final JClassType t : typeArgs) {
checkCanSerialize(logger, t);
}
if (parameterizedSerializers.containsKey(qsn)) {
return;
}
} else if (parameterizedSerializers.containsKey(qsn)) {
logger.log(TreeLogger.ERROR,
"Type " + qsn + " requires type paramter(s)", null);
throw new UnableToCompleteException();
}
if (qsn.startsWith("java.") || qsn.startsWith("javax.")) {
logger.log(TreeLogger.ERROR, "Standard type " + qsn
+ " not supported in JSON encoding", null);
throw new UnableToCompleteException();
}
if (type.isInterface() != null ) {
logger.log(TreeLogger.ERROR, "Interface " + qsn
+ " not supported in JSON encoding", null);
throw new UnableToCompleteException();
}
final JClassType ct = (JClassType) type;
if ( checkedType.contains( ct))
{
return;
}
checkedType.add( ct );
if (ct.isAbstract() && !allowAbstractType) {
logger.log(TreeLogger.ERROR, "Abstract type " + qsn
+ " not supported here", null);
throw new UnableToCompleteException();
}
for (final JField f : sortFields(ct)) {
final TreeLogger branch =
logger.branch(TreeLogger.DEBUG, "In type " + qsn + ", field "
+ f.getName());
checkCanSerialize(branch, f.getType());
}
}
String serializerFor(final JType t) {
if (t.isArray() != null) {
final JType componentType = t.isArray().getComponentType();
if (componentType.isPrimitive() != null
|| isBoxedPrimitive(componentType))
return PrimitiveArraySerializer.class.getCanonicalName();
else
return ObjectArraySerializer.class.getCanonicalName() + "<"
+ componentType.getQualifiedSourceName() + ">";
}
if (isStringMap(t)) {
return StringMapSerializer.class.getName();
}
final String qsn = t.getQualifiedSourceName();
if (defaultSerializers.containsKey(qsn)) {
return defaultSerializers.get(qsn);
}
if (parameterizedSerializers.containsKey(qsn)) {
return parameterizedSerializers.get(qsn);
}
return generatedSerializers.get(qsn);
}
private boolean isStringMap(final JType t) {
return t.isParameterized() != null
&& t.getErasedType().isClassOrInterface() != null
&& t.isParameterized().getTypeArgs().length > 0
&& t.isParameterized().getTypeArgs()[0].getQualifiedSourceName()
.equals(String.class.getName())
&& t.getErasedType().isClassOrInterface().isAssignableTo(
context.getTypeOracle().findType(Map.class.getName()));
}
private void generateSingleton(final SourceWriter w) {
w.print("public static final ");
w.print(getSerializerSimpleName());
w.print(" INSTANCE = new ");
w.print(getSerializerSimpleName());
w.println("();");
w.println();
}
private void generateInstanceMembers(final SourceWriter w) {
for (final JField f : sortFields(targetType)) {
final JType ft = f.getType();
if (needsTypeParameter(ft)) {
final String serType = serializerFor(ft);
w.print("private final ");
w.print(serType);
w.print(" ");
w.print("ser_" + f.getName());
w.print(" = ");
generateSerializerReference(ft, w);
w.println(";");
}
}
w.println();
}
void generateSerializerReference(final JType type, final SourceWriter w) {
String serializerFor = serializerFor(type);
if (type.isArray() != null) {
final JType componentType = type.isArray().getComponentType();
if (componentType.isPrimitive() != null
|| isBoxedPrimitive(componentType)) {
w.print(PrimitiveArraySerializer.class.getCanonicalName());
w.print(".INSTANCE");
} else {
w.print("new " + serializerFor + "(");
generateSerializerReference(componentType, w);
w.print(")");
}
} else if (needsTypeParameter(type)) {
w.print("new " + serializerFor + "(");
final JClassType[] typeArgs = type.isParameterized().getTypeArgs();
int n = 0;
if (isStringMap(type)) {
n++;
}
boolean first = true;
for (; n < typeArgs.length; n++) {
if (first) {
first = false;
} else {
w.print(", ");
}
generateSerializerReference(typeArgs[n], w);
}
w.print(")");
} else {
w.print(serializerFor + ".INSTANCE");
}
}
private void generateGetSets(final SourceWriter w) {
for (final JField f : sortFields(targetType)) {
if (f.isPrivate()) {
w.print("private static final native ");
w.print(f.getType().getQualifiedSourceName());
w.print(" objectGet_" + f.getName());
w.print("(");
w.print(targetType.getQualifiedSourceName() + " instance");
w.print(")");
w.println("/*-{ ");
w.indent();
w.print("return instance.@");
w.print(targetType.getQualifiedSourceName());
w.print("::");
w.print(f.getName());
w.println(";");
w.outdent();
w.println("}-*/;");
w.print("private static final native void ");
w.print(" objectSet_" + f.getName());
w.print("(");
w.print(targetType.getQualifiedSourceName() + " instance, ");
w.print(f.getType().getQualifiedSourceName() + " value");
w.print(")");
w.println("/*-{ ");
w.indent();
w.print("instance.@");
w.print(targetType.getQualifiedSourceName());
w.print("::");
w.print(f.getName());
w.println(" = value;");
w.outdent();
w.println("}-*/;");
}
if (f.getType() == JPrimitiveType.CHAR || isBoxedCharacter(f.getType())) {
w.print("private static final native String");
w.print(" jsonGet0_" + f.getName());
w.print("(final JavaScriptObject instance)");
w.println("/*-{ ");
w.indent();
w.print("return instance.");
w.print(f.getName());
w.println(";");
w.outdent();
w.println("}-*/;");
w.print("private static final ");
w.print(f.getType() == JPrimitiveType.CHAR ? "char" : "Character");
w.print(" jsonGet_" + f.getName());
w.print("(JavaScriptObject instance)");
w.println(" {");
w.indent();
w.print("return ");
w.print(JsonSerializer.class.getName());
w.print(".toChar(");
w.print("jsonGet0_" + f.getName());
w.print("(instance)");
w.println(");");
w.outdent();
w.println("}");
} else {
w.print("private static final native ");
if (f.getType().isArray() != null) {
w.print("JavaScriptObject");
} else if (isJsonPrimitive(f.getType())) {
w.print(f.getType().getQualifiedSourceName());
} else if (isBoxedPrimitive(f.getType())) {
w.print(boxedTypeToPrimitiveTypeName(f.getType()));
} else {
w.print("Object");
}
w.print(" jsonGet_" + f.getName());
w.print("(JavaScriptObject instance)");
w.println("/*-{ ");
w.indent();
w.print("return instance.");
w.print(f.getName());
w.println(";");
w.outdent();
w.println("}-*/;");
}
w.println();
}
}
private void generateEnumFromJson(final SourceWriter w) {
w.print("public ");
w.print(targetType.getQualifiedSourceName());
w.println(" fromJson(Object in) {");
w.indent();
w.print("return in != null");
w.print(" ? " + targetType.getQualifiedSourceName()
+ ".valueOf((String)in)");
w.print(" : null");
w.println(";");
w.outdent();
w.println("}");
w.println();
}
private void generatePrintJson(final SourceWriter w) {
final JField[] fieldList = sortFields(targetType);
w.print("protected int printJsonImpl(int fieldCount, StringBuilder sb, ");
w.println("Object instance) {");
w.indent();
w.print("final ");
w.print(targetType.getQualifiedSourceName());
w.print(" src = (");
w.print(targetType.getQualifiedSourceName());
w.println(")instance;");
if (needsSuperSerializer(targetType)) {
w.print("fieldCount = super.printJsonImpl(fieldCount, sb, (");
w.print(targetType.getSuperclass().getQualifiedSourceName());
w.println(")src);");
}
final String docomma = "if (fieldCount++ > 0) sb.append(\",\");";
for (final JField f : fieldList) {
final String doget;
if (f.isPrivate()) {
doget = "objectGet_" + f.getName() + "(src)";
} else {
doget = "src." + f.getName();
}
final String doname = "sb.append(\"\\\"" + f.getName() + "\\\":\");";
if (f.getType() == JPrimitiveType.CHAR || isBoxedCharacter(f.getType())) {
w.println(docomma);
w.println(doname);
w.println("sb.append(\"\\\"\");");
w.println("sb.append(" + JsonSerializer.class.getSimpleName()
+ ".escapeChar(" + doget + "));");
w.println("sb.append(\"\\\"\");");
} else if (isJsonString(f.getType())) {
w.println("if (" + doget + " != null) {");
w.indent();
w.println(docomma);
w.println(doname);
w.println("sb.append(" + JsonSerializer.class.getSimpleName()
+ ".escapeString(" + doget + "));");
w.outdent();
w.println("}");
w.println();
} else if (isJsonPrimitive(f.getType()) || isBoxedPrimitive(f.getType())) {
w.println(docomma);
w.println(doname);
w.println("sb.append(" + doget + ");");
w.println();
} else {
w.println("if (" + doget + " != null) {");
w.indent();
w.println(docomma);
w.println(doname);
if (needsTypeParameter(f.getType())) {
w.print("ser_" + f.getName());
} else {
w.print(serializerFor(f.getType()) + ".INSTANCE");
}
w.println(".printJson(sb, " + doget + ");");
w.outdent();
w.println("}");
w.println();
}
}
w.println("return fieldCount;");
w.outdent();
w.println("}");
w.println();
}
private void generateFromJson(final SourceWriter w) {
w.print("public ");
w.print(targetType.getQualifiedSourceName());
w.println(" fromJson(Object in) {");
w.indent();
if (targetType.isAbstract()) {
w.println("throw new UnsupportedOperationException();");
} else {
w.println("if (in == null) return null;");
w.println("final JavaScriptObject jso = (JavaScriptObject)in;");
w.print("final ");
w.print(targetType.getQualifiedSourceName());
w.print(" dst = new ");
w.println(targetType.getQualifiedSourceName() + "();");
w.println("fromJsonImpl(jso, dst);");
w.println("return dst;");
}
w.outdent();
w.println("}");
w.println();
w.print("protected void fromJsonImpl(JavaScriptObject jso,");
w.print(targetType.getQualifiedSourceName());
w.println(" dst) {");
w.indent();
if (needsSuperSerializer(targetType)) {
w.print("super.fromJsonImpl(jso, (");
w.print(targetType.getSuperclass().getQualifiedSourceName());
w.println(")dst);");
}
for (final JField f : sortFields(targetType)) {
final String doget = "jsonGet_" + f.getName() + "(jso)";
final String doset0, doset1;
if (f.isPrivate()) {
doset0 = "objectSet_" + f.getName() + "(dst, ";
doset1 = ")";
} else {
doset0 = "dst." + f.getName() + " = ";
doset1 = "";
}
JType type = f.getType();
if (type.isArray() != null) {
final JType ct = type.isArray().getComponentType();
w.println("if (" + doget + " != null) {");
w.indent();
w.print("final ");
w.print(ct.getQualifiedSourceName());
w.print("[] tmp = new ");
w.print(ct.getQualifiedSourceName());
w.print("[");
w.print(ObjectArraySerializer.class.getName());
w.print(".size(" + doget + ")");
w.println("];");
w.println("ser_" + f.getName() + ".fromJson(" + doget + ", tmp);");
w.print(doset0);
w.print("tmp");
w.print(doset1);
w.println(";");
w.outdent();
w.println("}");
} else if (isJsonPrimitive(type)) {
w.print(doset0);
w.print(doget);
w.print(doset1);
w.println(";");
} else if (isBoxedPrimitive(type)) {
w.print(doset0);
w.print("new " + type.getQualifiedSourceName() + "(");
w.print(doget);
w.print(")");
w.print(doset1);
w.println(";");
} else {
w.print(doset0);
if (needsTypeParameter(type)) {
w.print("ser_" + f.getName());
} else {
String serializerFor = serializerFor(type);
w.print(serializerFor + ".INSTANCE");
}
w.print(".fromJson(" + doget + ")");
w.print(doset1);
w.println(";");
}
}
w.outdent();
w.println("}");
w.println();
}
static boolean isJsonPrimitive(final JType t) {
return t.isPrimitive() != null || isJsonString(t);
}
static boolean isBoxedPrimitive(final JType t) {
final String qsn = t.getQualifiedSourceName();
return qsn.equals(Boolean.class.getCanonicalName())
|| qsn.equals(Byte.class.getCanonicalName()) || isBoxedCharacter(t)
|| qsn.equals(Double.class.getCanonicalName())
|| qsn.equals(Float.class.getCanonicalName())
|| qsn.equals(Integer.class.getCanonicalName())
|| qsn.equals(Short.class.getCanonicalName());
}
static boolean isBoxedCharacter(JType t) {
return t.getQualifiedSourceName()
.equals(Character.class.getCanonicalName());
}
private String boxedTypeToPrimitiveTypeName(JType t) {
final String qsn = t.getQualifiedSourceName();
if (qsn.equals(Boolean.class.getCanonicalName())) return "boolean";
if (qsn.equals(Byte.class.getCanonicalName())) return "byte";
if (qsn.equals(Character.class.getCanonicalName()))
return "java.lang.String";
if (qsn.equals(Double.class.getCanonicalName())) return "double";
if (qsn.equals(Float.class.getCanonicalName())) return "float";
if (qsn.equals(Integer.class.getCanonicalName())) return "int";
if (qsn.equals(Short.class.getCanonicalName())) return "short";
throw new IllegalArgumentException(t + " is not a boxed type");
}
static boolean isJsonString(final JType t) {
return t.getQualifiedSourceName().equals(String.class.getCanonicalName());
}
private SourceWriter getSourceWriter(final TreeLogger logger,
final GeneratorContext ctx) {
final JPackage targetPkg = targetType.getPackage();
final String pkgName = targetPkg == null ? "" : targetPkg.getName();
final PrintWriter pw;
final ClassSourceFileComposerFactory cf;
pw = ctx.tryCreate(logger, pkgName, getSerializerSimpleName());
if (pw == null) {
return null;
}
cf = new ClassSourceFileComposerFactory(pkgName, getSerializerSimpleName());
cf.addImport(JavaScriptObject.class.getCanonicalName());
cf.addImport(JsonSerializer.class.getCanonicalName());
if (targetType.isEnum() != null) {
cf.addImport(EnumSerializer.class.getCanonicalName());
cf.setSuperclass(EnumSerializer.class.getSimpleName() + "<"
+ targetType.getQualifiedSourceName() + ">");
} else if (needsSuperSerializer(targetType)) {
cf.setSuperclass(getSerializerQualifiedName(targetType.getSuperclass()));
} else {
cf.addImport(ObjectSerializer.class.getCanonicalName());
cf.setSuperclass(ObjectSerializer.class.getSimpleName() + "<"
+ targetType.getQualifiedSourceName() + ">");
}
return cf.createSourceWriter(ctx, pw);
}
private static boolean needsSuperSerializer(JClassType type) {
type = type.getSuperclass();
while (!Object.class.getName().equals(type.getQualifiedSourceName())) {
if (sortFields(type).length > 0) {
return true;
}
type = type.getSuperclass();
}
return false;
}
private String getSerializerQualifiedName(final JClassType targetType) {
final String[] name;
name = ProxyCreator.synthesizeTopLevelClassName(targetType, SER_SUFFIX);
return name[0].length() == 0 ? name[1] : name[0] + "." + name[1];
}
private String getSerializerSimpleName() {
return ProxyCreator.synthesizeTopLevelClassName(targetType, SER_SUFFIX)[1];
}
static boolean needsTypeParameter(final JType ft) {
return ft.isArray() != null
|| (ft.isParameterized() != null && parameterizedSerializers
.containsKey(ft.getQualifiedSourceName()));
}
private static JField[] sortFields(final JClassType targetType) {
final ArrayList<JField> r = new ArrayList<JField>();
for (final JField f : targetType.getFields()) {
if (!f.isStatic() && !f.isTransient() && !f.isFinal()) {
r.add(f);
}
}
Collections.sort(r, FIELD_COMP);
return r.toArray(new JField[r.size()]);
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/rebind/SerializerCreator.java | Java | gpl3 | 25,866 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.rebind;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Set;
import org.rapla.rest.gwtjsonrpc.client.CallbackHandle;
import org.rapla.rest.gwtjsonrpc.client.impl.AbstractJsonProxy;
import org.rapla.rest.gwtjsonrpc.client.impl.FutureResultImpl;
import org.rapla.rest.gwtjsonrpc.client.impl.JsonSerializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import org.rapla.rest.gwtjsonrpc.client.impl.v2_0.JsonCall20HttpGet;
import org.rapla.rest.gwtjsonrpc.client.impl.v2_0.JsonCall20HttpPost;
import org.rapla.rest.gwtjsonrpc.common.FutureResult;
import org.rapla.rest.gwtjsonrpc.common.RpcImpl;
import org.rapla.rest.gwtjsonrpc.common.RpcImpl.Transport;
import org.rapla.rest.gwtjsonrpc.common.RpcImpl.Version;
import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.TreeLogger.Type;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JArrayType;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JPackage;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JParameterizedType;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.dev.generator.NameFactory;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;
class ProxyCreator {
private static final String PROXY_SUFFIX = "_JsonProxy";
private JClassType svcInf;
//private JClassType asyncCallbackClass;
//private JClassType futureResultInterface;
String futureResultClassName;
//private JClassType futureResultClass;
private SerializerCreator serializerCreator;
private ResultDeserializerCreator deserializerCreator;
private int instanceField;
ProxyCreator(final JClassType remoteService) {
svcInf = remoteService;
}
String create(final TreeLogger logger, final GeneratorContext context)
throws UnableToCompleteException {
serializerCreator = new SerializerCreator(context);
deserializerCreator = new ResultDeserializerCreator(context, serializerCreator);
futureResultClassName = FutureResultImpl.class.getName();
//final TypeOracle typeOracle = context.getTypeOracle();
//try {
//asyncCallbackClass = typeOracle.getType(AsyncCallback.class.getName());
//String futureResultInterfaceName = FutureResult.class.getName();
//futureResultInterface = typeOracle.getType(futureResultInterfaceName);
// futureResultClass = typeOracle.getType(futureResultClassName);
// } catch (NotFoundException e) {
// logger.log(TreeLogger.ERROR, null, e);
// throw new UnableToCompleteException();
// }
checkMethods(logger, context);
final SourceWriter srcWriter = getSourceWriter(logger, context);
if (srcWriter == null) {
return getProxyQualifiedName();
}
generateProxyConstructor(logger, srcWriter);
generateProxyCallCreator(logger, srcWriter);
generateProxyMethods(logger, srcWriter);
srcWriter.commit(logger);
return getProxyQualifiedName();
}
private void checkMethods(final TreeLogger logger,
@SuppressWarnings("unused") final GeneratorContext context) throws UnableToCompleteException {
final Set<String> declaredNames = new HashSet<String>();
final JMethod[] methodList = svcInf.getOverridableMethods();
for (final JMethod m : methodList) {
if (!declaredNames.add(m.getName())) {
invalid(logger, "Overloading method " + m.getName() + " not supported");
}
final JParameter[] params = m.getParameters();
// if (m.getReturnType() != JPrimitiveType.VOID && !returnsCallbackHandle(m)) {
// invalid(logger, "Method " + m.getName() + " must return void or "
// + CallbackHandle.class);
// }
//
// if (params.length == 0) {
// invalid(logger, "Method " + m.getName() + " requires "
// + AsyncCallback.class.getName() + " as last parameter");
// }
//
// final JParameter callback = params[params.length - 1];
// if (!callback.getType().getErasedType().getQualifiedSourceName().equals(
// asyncCallbackClass.getQualifiedSourceName())) {
// invalid(logger, "Method " + m.getName() + " requires "
// + AsyncCallback.class.getName() + " as last parameter");
// }
// if (callback.getType().isParameterized() == null) {
// invalid(logger, "Callback " + callback.getName()
// + " must have a type parameter");
// }
final JType callback = m.getReturnType();
// if (!callback.getErasedType().getQualifiedSourceName().equals(
// futureResultInterface.getQualifiedSourceName())) {
// invalid(logger, "Method " + m.getName() + " requires "
// + FutureResult.class.getName() + " as return type");
// }
// if (callback.isParameterized() == null) {
// invalid(logger, "FutureResult must have a type parameter");
// }
final JClassType resultType =callback.isParameterized().getTypeArgs()[0];
//final JType resultType =callback;
// if (returnsCallbackHandle(m)) {
// if (params.length != 1) {
// invalid(logger, "Method " + m.getName()
// + " must not accept parameters");
// }
//
// final JClassType rt = m.getReturnType().isClass();
// if (rt.isParameterized() == null) {
// invalid(logger, "CallbackHandle return value of " + m.getName()
// + " must have a type parameter");
// }
// if (!resultType.getQualifiedSourceName().equals(
// rt.isParameterized().getTypeArgs()[0].getQualifiedSourceName())) {
// invalid(logger, "CallbackHandle return value of " + m.getName()
// + " must match type with AsyncCallback parameter");
// }
// }
// if (m.getAnnotation(HostPageCache.class) != null) {
// if (m.getReturnType() != JPrimitiveType.VOID) {
// invalid(logger, "Method " + m.getName()
// + " must return void if using " + HostPageCache.class.getName());
// }
// if (params.length != 1) {
// invalid(logger, "Method " + m.getName()
// + " must not accept parameters");
// }
// }
for (int i = 0; i < params.length /*- 1*/; i++) {
final JParameter p = params[i];
final TreeLogger branch =
logger.branch(TreeLogger.DEBUG, m.getName() + ", parameter "
+ p.getName());
serializerCreator.checkCanSerialize(branch, p.getType());
if (p.getType().isPrimitive() == null
&& !SerializerCreator.isBoxedPrimitive(p.getType())) {
serializerCreator.create((JClassType) p.getType(), branch);
}
}
{
JClassType p = resultType;
final TreeLogger branch =
logger.branch(TreeLogger.DEBUG, m.getName() + ", result "
+ p.getName());
if (p.isPrimitive() == null
&& !SerializerCreator.isBoxedPrimitive(p)) {
serializerCreator.create((JClassType) p, branch);
}
}
final TreeLogger branch =
logger.branch(TreeLogger.DEBUG, m.getName() + ", result "
+ resultType.getQualifiedSourceName());
if ( resultType.getQualifiedSourceName().startsWith(FutureResult.class.getName()))
{
JParameterizedType parameterized = resultType.isParameterized();
JClassType jClassType = parameterized.getTypeArgs()[0];
serializerCreator.checkCanSerialize(branch, jClassType);
}
else
{
serializerCreator.checkCanSerialize(branch, resultType);
}
if (resultType.isArray() != null) {
// Arrays need a special deserializer
deserializerCreator.create(branch, resultType.isArray());
} else if (resultType.isPrimitive() == null
&& !SerializerCreator.isBoxedPrimitive(resultType))
// Non primitives get deserialized by their normal serializer
serializerCreator.create((JClassType)resultType, branch);
// (Boxed)Primitives are left, they are handled specially
}
}
private boolean returnsCallbackHandle(final JMethod m) {
return m.getReturnType().getErasedType().getQualifiedSourceName().equals(
CallbackHandle.class.getName());
}
private void invalid(final TreeLogger logger, final String what)
throws UnableToCompleteException {
logger.log(TreeLogger.ERROR, what, null);
throw new UnableToCompleteException();
}
private SourceWriter getSourceWriter(final TreeLogger logger,
final GeneratorContext ctx) {
final JPackage servicePkg = svcInf.getPackage();
final String pkgName = servicePkg == null ? "" : servicePkg.getName();
final PrintWriter pw;
final ClassSourceFileComposerFactory cf;
pw = ctx.tryCreate(logger, pkgName, getProxySimpleName());
if (pw == null) {
return null;
}
cf = new ClassSourceFileComposerFactory(pkgName, getProxySimpleName());
cf.addImport(AbstractJsonProxy.class.getCanonicalName());
cf.addImport(JsonSerializer.class.getCanonicalName());
cf.addImport(JavaScriptObject.class.getCanonicalName());
cf.addImport(ResultDeserializer.class.getCanonicalName());
cf.addImport(FutureResultImpl.class.getCanonicalName());
cf.addImport(GWT.class.getCanonicalName());
cf.setSuperclass(AbstractJsonProxy.class.getSimpleName());
cf.addImplementedInterface(svcInf.getErasedType().getQualifiedSourceName());
return cf.createSourceWriter(ctx, pw);
}
private void generateProxyConstructor(@SuppressWarnings("unused") final TreeLogger logger,
final SourceWriter w) {
final RemoteServiceRelativePath relPath =
svcInf.getAnnotation(RemoteServiceRelativePath.class);
if (relPath != null) {
w.println();
w.println("public " + getProxySimpleName() + "() {");
w.indent();
w.println("setServiceEntryPoint(GWT.getModuleBaseURL() + \""
+ relPath.value() + "\");");
w.outdent();
w.println("}");
}
}
private void generateProxyCallCreator(final TreeLogger logger,
final SourceWriter w) throws UnableToCompleteException {
String callName = getJsonCallClassName(logger);
w.println();
w.println("@Override");
w.print("protected <T> ");
w.print(callName);
w.print("<T> newJsonCall(final AbstractJsonProxy proxy, ");
w.print("final String methodName, final String reqData, ");
w.println("final ResultDeserializer<T> ser) {");
w.indent();
w.print("return new ");
w.print(callName);
w.println("<T>(proxy, methodName, reqData, ser);");
w.outdent();
w.println("}");
}
private String getJsonCallClassName(final TreeLogger logger)
throws UnableToCompleteException {
RpcImpl impl = svcInf.getAnnotation(RpcImpl.class);
if (impl == null) {
return JsonCall20HttpPost.class.getCanonicalName();
} else if (impl.version() == Version.V2_0
&& impl.transport() == Transport.HTTP_POST) {
return JsonCall20HttpPost.class.getCanonicalName();
} else if (impl.version() == Version.V2_0
&& impl.transport() == Transport.HTTP_GET) {
return JsonCall20HttpGet.class.getCanonicalName();
}
logger.log(Type.ERROR, "Unsupported JSON-RPC version and transport "
+ "combination: Supported are 1.1 over HTTP POST and "
+ "2.0 over HTTP POST and GET");
throw new UnableToCompleteException();
}
private void generateProxyMethods(final TreeLogger logger,
final SourceWriter srcWriter) {
final JMethod[] methodList = svcInf.getOverridableMethods();
for (final JMethod m : methodList) {
generateProxyMethod(logger, m, srcWriter);
}
}
private void generateProxyMethod(@SuppressWarnings("unused") final TreeLogger logger,
final JMethod method, final SourceWriter w) {
final JParameter[] params = method.getParameters();
final JType callback = method.getReturnType();// params[params.length - 1];
JType resultType = callback;
// final JClassType resultType =
// callback.isParameterized().getTypeArgs()[0];
final String[] serializerFields = new String[params.length];
String resultField = "";
w.println();
for (int i = 0; i < params.length /*- 1*/; i++) {
final JType pType = params[i].getType();
if (SerializerCreator.needsTypeParameter(pType)) {
serializerFields[i] = "serializer_" + instanceField++;
w.print("private static final ");
if (pType.isArray() != null)
w.print(serializerCreator.serializerFor(pType));
else
w.print(JsonSerializer.class.getName());
w.print(" ");
w.print(serializerFields[i]);
w.print(" = ");
serializerCreator.generateSerializerReference(pType, w);
w.println(";");
}
}
JClassType parameterizedResult = null;
if (resultType.isParameterized() != null) {
resultField = "serializer_" + instanceField++;
w.print("private static final ");
w.print(ResultDeserializer.class.getName());
w.print(" ");
w.print(resultField);
w.print(" = ");
parameterizedResult = resultType.isParameterized().getTypeArgs()[0];
serializerCreator.generateSerializerReference(parameterizedResult, w);
w.println(";");
}
w.print("public ");
w.print(method.getReturnType().getQualifiedSourceName());
w.print(" ");
w.print(method.getName());
w.print("(");
boolean needsComma = false;
final NameFactory nameFactory = new NameFactory();
for (int i = 0; i < params.length; i++) {
final JParameter param = params[i];
if (needsComma) {
w.print(", ");
} else {
needsComma = true;
}
final JType paramType = param.getType().getErasedType();
w.print(paramType.getQualifiedSourceName());
w.print(" ");
nameFactory.addName(param.getName());
w.print(param.getName());
}
w.println(") {");
w.indent();
if (returnsCallbackHandle(method)) {
w.print("return new ");
w.print(CallbackHandle.class.getName());
w.print("(");
if (SerializerCreator.needsTypeParameter(resultType)) {
w.print(resultField);
} else {
deserializerCreator.generateDeserializerReference(resultType, w);
}
w.print(", " + "null" // callback.getName()
);
w.println(");");
w.outdent();
w.println("}");
return;
}
// final HostPageCache hpc = method.getAnnotation(HostPageCache.class);
// if (hpc != null) {
// final String objName = nameFactory.createName("cached");
// w.print("final JavaScriptObject " + objName + " = ");
// w.print(AbstractJsonProxy.class.getName());
// w.print(".");
// w.print(hpc.once() ? "hostPageCacheGetOnce" : "hostPageCacheGetMany");
// w.println("(\"" + hpc.name() + "\");");
// w.println("if (" + objName + " != null) {");
// w.indent();
// w.print(JsonUtil.class.getName());
// w.print(".invoke(");
// if (SerializerCreator.needsTypeParameter(resultType)) {
// w.print(resultField);
// } else {
// deserializerCreator.generateDeserializerReference(resultType, w);
// }
// // w.print(", " + callback.getName());
// w.print(", " + "null");
// w.print(", " + objName);
// w.println(");");
// w.println("return;");
// w.outdent();
// w.println("}");
// }
final String reqDataStr;
if (params.length == 1) {
reqDataStr = "\"[]\"";
} else {
final String reqData = nameFactory.createName("reqData");
w.println("final StringBuilder " + reqData + " = new StringBuilder();");
needsComma = false;
w.println(reqData + ".append('[');");
for (int i = 0; i < params.length; i++) {
if (needsComma) {
w.println(reqData + ".append(\",\");");
} else {
needsComma = true;
}
final JType pType = params[i].getType();
final String pName = params[i].getName();
if (pType == JPrimitiveType.CHAR
|| SerializerCreator.isBoxedCharacter(pType)) {
w.println(reqData + ".append(\"\\\"\");");
w.println(reqData + ".append(" + JsonSerializer.class.getSimpleName()
+ ".escapeChar(" + pName + "));");
w.println(reqData + ".append(\"\\\"\");");
} else if ((SerializerCreator.isJsonPrimitive(pType) || SerializerCreator
.isBoxedPrimitive(pType))
&& !SerializerCreator.isJsonString(pType)) {
w.println(reqData + ".append(" + pName + ");");
} else {
w.println("if (" + pName + " != null) {");
w.indent();
if (SerializerCreator.needsTypeParameter(pType)) {
w.print(serializerFields[i]);
} else {
serializerCreator.generateSerializerReference(pType, w);
}
w.println(".printJson(" + reqData + ", " + pName + ");");
w.outdent();
w.println("} else {");
w.indent();
w.println(reqData + ".append(" + JsonSerializer.class.getName()
+ ".JS_NULL);");
w.outdent();
w.println("}");
}
}
w.println(reqData + ".append(']');");
reqDataStr = reqData + ".toString()";
}
String resultClass = futureResultClassName;
if (parameterizedResult != null)
{
resultClass+="<" + parameterizedResult.getQualifiedSourceName()+ ">";
}
w.println( resultClass + " result = new " + resultClass + "();");
w.print("doInvoke(");
w.print("\"" + method.getName() + "\"");
w.print(", " + reqDataStr);
w.print(", ");
if (resultType.isParameterized() != null) {
w.print(resultField);
} else {
deserializerCreator.generateDeserializerReference(resultType, w);
}
//w.print(", " + callback.getName());
w.print(", result");
w.println(");");
w.println("return result;");
w.outdent();
w.println("}");
}
private String getProxyQualifiedName() {
final String[] name = synthesizeTopLevelClassName(svcInf, PROXY_SUFFIX);
return name[0].length() == 0 ? name[1] : name[0] + "." + name[1];
}
private String getProxySimpleName() {
return synthesizeTopLevelClassName(svcInf, PROXY_SUFFIX)[1];
}
static String[] synthesizeTopLevelClassName(JClassType type, String suffix) {
// Gets the basic name of the type. If it's a nested type, the type name
// will contains dots.
//
String className;
String packageName;
JType leafType = type.getLeafType();
if (leafType.isPrimitive() != null) {
className = leafType.getSimpleSourceName();
packageName = "";
} else {
JClassType classOrInterface = leafType.isClassOrInterface();
assert (classOrInterface != null);
className = classOrInterface.getName();
packageName = classOrInterface.getPackage().getName();
}
JParameterizedType isGeneric = type.isParameterized();
if (isGeneric != null) {
for (JClassType param : isGeneric.getTypeArgs()) {
className += "_";
className += param.getQualifiedSourceName().replace('.', '_');
}
}
JArrayType isArray = type.isArray();
if (isArray != null) {
className += "_Array_Rank_" + isArray.getRank();
}
// Add the meaningful suffix.
//
className += suffix;
// Make it a top-level name.
//
className = className.replace('.', '_');
return new String[] {packageName, className};
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/rebind/ProxyCreator.java | Java | gpl3 | 20,549 |
// Copyright 2008 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.rebind;
import com.google.gwt.core.ext.Generator;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
/**
* Generates proxy implementations of RemoteJsonService.
*/
public class RemoteJsonServiceProxyGenerator extends Generator {
@Override
public String generate(final TreeLogger logger, final GeneratorContext ctx,
final String requestedClass) throws UnableToCompleteException {
final TypeOracle typeOracle = ctx.getTypeOracle();
assert (typeOracle != null);
final JClassType remoteService = typeOracle.findType(requestedClass);
if (remoteService == null) {
logger.log(TreeLogger.ERROR, "Unable to find metadata for type '"
+ requestedClass + "'", null);
throw new UnableToCompleteException();
}
// WebService annotation = remoteService.getAnnotation( javax.jws.WebService.class);
// if (annotation == null)
// {
// return null;
// }
if (remoteService.isInterface() == null) {
logger.log(TreeLogger.ERROR, remoteService.getQualifiedSourceName()
+ " is not an interface", null);
throw new UnableToCompleteException();
}
ProxyCreator proxyCreator = new ProxyCreator(remoteService);
TreeLogger proxyLogger =
logger.branch(TreeLogger.DEBUG,
"Generating client proxy for remote service interface '"
+ remoteService.getQualifiedSourceName() + "'", null);
return proxyCreator.create(proxyLogger, ctx);
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/rebind/RemoteJsonServiceProxyGenerator.java | Java | gpl3 | 2,282 |
// Copyright 2009 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.rapla.rest.gwtjsonrpc.rebind;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.typeinfo.JArrayType;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;
import java.io.PrintWriter;
import java.util.HashMap;
import org.rapla.rest.gwtjsonrpc.client.impl.ArrayResultDeserializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ResultDeserializer;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.PrimitiveArrayResultDeserializers;
import org.rapla.rest.gwtjsonrpc.client.impl.ser.PrimitiveResultDeserializers;
/**
* Creator of ResultDeserializers. Actually, only object arrays have created
* deserializers:
* <ul>
* <li>Boxed primitives are handled by {@link PrimitiveResultDeserializers}
* <li>Normal objects have their (generated) serializers extending
* {@link com.google.gwtjsonrpc.client.ObjectSerializer}, that handle result
* deserialisation as well.
* <li>Arrays of (boxed) primitives are handled by
* {@link PrimitiveArrayResultDeserializers}.
* <li>And object arrays get a generated deserializer extending
* {@link ArrayResultDeserializer}
* </ul>
* All object arrays that have a JSONSerializer for the array component can be
* generated, but they will need to live in the same package as the serializer.
* To do this, if the serializer lives in the
* <code>com.google.gwtjsonrpc.client</code> package (where custom object
* serializers live), the ResultDeserializer for it's array will be placed in
* this package as well. Else it will be placed with the serializer in the
* package the object lives.
*/
class ResultDeserializerCreator {
private static final String DSER_SUFFIX = "_ResultDeserializer";
private GeneratorContext context;
private HashMap<String, String> generatedDeserializers;
private SerializerCreator serializerCreator;
private JArrayType targetType;
private JType componentType;
ResultDeserializerCreator(GeneratorContext c, SerializerCreator sc) {
context = c;
generatedDeserializers = new HashMap<String, String>();
serializerCreator = sc;
}
void create(TreeLogger logger, JArrayType targetType) {
this.targetType = targetType;
this.componentType = targetType.getComponentType();
if (componentType.isPrimitive() != null
|| SerializerCreator.isBoxedPrimitive(componentType)) {
logger.log(TreeLogger.DEBUG,
"No need to create array deserializer for primitive array "
+ targetType);
return;
}
if (deserializerFor(targetType) != null) {
return;
}
logger.log(TreeLogger.DEBUG, "Creating result deserializer for "
+ targetType.getSimpleSourceName());
final SourceWriter srcWriter = getSourceWriter(logger, context);
if (srcWriter == null) {
return;
}
final String dsn = getDeserializerQualifiedName(targetType);
generatedDeserializers.put(targetType.getQualifiedSourceName(), dsn);
generateSingleton(srcWriter);
generateInstanceMembers(srcWriter);
generateFromResult(srcWriter);
srcWriter.commit(logger);
}
private void generateSingleton(final SourceWriter w) {
w.print("public static final ");
w.print(getDeserializerSimpleName(targetType));
w.print(" INSTANCE = new ");
w.print(getDeserializerSimpleName(targetType));
w.println("();");
w.println();
}
private void generateInstanceMembers(SourceWriter w) {
w.print("private final ");
w.print(serializerCreator.serializerFor(targetType));
w.print(" ");
w.print("serializer");
w.print(" = ");
serializerCreator.generateSerializerReference(targetType, w);
w.println(";");
w.println();
}
private void generateFromResult(SourceWriter w) {
final String ctn = componentType.getQualifiedSourceName();
w.println("@Override");
w.print("public " + ctn + "[] ");
w.println("fromResult(JavaScriptObject responseObject) {");
w.indent();
w.print("final " + ctn + "[] tmp = new " + ctn);
w.println("[getResultSize(responseObject)];");
w.println("serializer.fromJson(getResult(responseObject), tmp);");
w.println("return tmp;");
w.outdent();
w.println("}");
}
private String getDeserializerQualifiedName(JArrayType targetType) {
final String pkgName = getDeserializerPackageName(targetType);
final String className = getDeserializerSimpleName(targetType);
return pkgName.length() == 0 ? className : pkgName + "." + className;
}
private String getDeserializerPackageName(JArrayType targetType) {
// Place array deserializer in same package as the component deserializer
final String compSerializer =
serializerCreator.serializerFor(targetType.getComponentType());
final int end = compSerializer.lastIndexOf('.');
return end >= 0 ? compSerializer.substring(0, end) : "";
}
private static String getDeserializerSimpleName(JClassType targetType) {
return ProxyCreator.synthesizeTopLevelClassName(targetType, DSER_SUFFIX)[1];
}
private SourceWriter getSourceWriter(TreeLogger logger,
GeneratorContext context) {
String pkgName = getDeserializerPackageName(targetType);
final String simpleName = getDeserializerSimpleName(targetType);
final PrintWriter pw;
final ClassSourceFileComposerFactory cf;
pw = context.tryCreate(logger, pkgName, simpleName);
if (pw == null) {
return null;
}
cf = new ClassSourceFileComposerFactory(pkgName, simpleName);
cf.addImport(JavaScriptObject.class.getCanonicalName());
cf.addImport(ResultDeserializer.class.getCanonicalName());
cf.setSuperclass(ArrayResultDeserializer.class.getCanonicalName());
cf.addImplementedInterface(ResultDeserializer.class.getCanonicalName()
+ "<" + targetType.getQualifiedSourceName() + ">");
return cf.createSourceWriter(context, pw);
}
private String deserializerFor(JArrayType targetType) {
final JType componentType = targetType.getComponentType();
// Custom primitive deserializers
if (SerializerCreator.isBoxedPrimitive(componentType))
return PrimitiveArrayResultDeserializers.class.getCanonicalName() + "."
+ componentType.getSimpleSourceName().toUpperCase() + "_INSTANCE";
final String name =
generatedDeserializers.get(targetType.getQualifiedSourceName());
return name == null ? null : name + ".INSTANCE";
}
public void generateDeserializerReference(JType targetType, SourceWriter w) {
if (SerializerCreator.isBoxedPrimitive(targetType)) {
w.print(PrimitiveResultDeserializers.class.getCanonicalName());
w.print(".");
w.print(targetType.getSimpleSourceName().toUpperCase());
w.print("_INSTANCE");
} else if (targetType.isArray() != null) {
w.print(deserializerFor(targetType.isArray()));
} else {
serializerCreator.generateSerializerReference(targetType, w);
}
}
}
| 04900db4-rob | gwt-src/org/rapla/rest/gwtjsonrpc/rebind/ResultDeserializerCreator.java | Java | gpl3 | 7,721 |
@echo off
:: -------------------------------------------------------------------------
:: build.bat Skript for Rapla
::
::
:: Usage:
:: for a list of all available build-targets type
:: .\build.bat -projecthelp
if not "%ANT_HOME%" =="" goto gotAntHome
set JAVA_HOME=C:\entwicklung\Java\jdk1.7.0_51
set ANT_HOME=.
:gotAntHome
call %ANT_HOME%\bin\ant.bat %1 %2 %3 %4 %5 %6
pause
| 04900db4-rob | build.bat | Batchfile | gpl3 | 379 |
#!/bin/sh
#
# Usage:
#
# for a list of all available build-targets type
# ./build.sh -projecthelp
#
chmod u+x ./bin/antRun
chmod u+x ./bin/ant
export ANT_HOME=.
$PWD/bin/ant -logger org.apache.tools.ant.NoBannerLogger -emacs $@
| 04900db4-rob | build.sh | Shell | gpl3 | 234 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.utils.GraphCanvas;
import nl.sogeti.android.gpstracker.actions.utils.StatisticsCalulator;
import nl.sogeti.android.gpstracker.actions.utils.StatisticsDelegate;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.util.UnitsI18n;
import nl.sogeti.android.gpstracker.viewer.TrackList;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.content.ContentResolver;
import android.content.Intent;
import android.database.ContentObserver;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.ContextMenu;
import android.view.GestureDetector;
import android.view.GestureDetector.SimpleOnGestureListener;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.Button;
import android.widget.TextView;
import android.widget.ViewFlipper;
/**
* Display some calulations based on a track
*
* @version $Id$
* @author rene (c) Oct 19, 2009, Sogeti B.V.
*/
public class Statistics extends Activity implements StatisticsDelegate
{
private static final int DIALOG_GRAPHTYPE = 3;
private static final int MENU_GRAPHTYPE = 11;
private static final int MENU_TRACKLIST = 12;
private static final int MENU_SHARE = 41;
private static final String TRACKURI = "TRACKURI";
private static final String TAG = "OGT.Statistics";
private static final int SWIPE_MIN_DISTANCE = 120;
private static final int SWIPE_MAX_OFF_PATH = 250;
private static final int SWIPE_THRESHOLD_VELOCITY = 200;
private Uri mTrackUri = null;
private boolean calculating;
private TextView overallavgSpeedView;
private TextView avgSpeedView;
private TextView distanceView;
private TextView endtimeView;
private TextView starttimeView;
private TextView maxSpeedView;
private TextView waypointsView;
private TextView mAscensionView;
private TextView mElapsedTimeView;
private UnitsI18n mUnits;
private GraphCanvas mGraphTimeSpeed;
private ViewFlipper mViewFlipper;
private Animation mSlideLeftIn;
private Animation mSlideLeftOut;
private Animation mSlideRightIn;
private Animation mSlideRightOut;
private GestureDetector mGestureDetector;
private GraphCanvas mGraphDistanceSpeed;
private GraphCanvas mGraphTimeAltitude;
private GraphCanvas mGraphDistanceAltitude;
private final ContentObserver mTrackObserver = new ContentObserver( new Handler() )
{
@Override
public void onChange( boolean selfUpdate )
{
if( !calculating )
{
Statistics.this.drawTrackingStatistics();
}
}
};
private OnClickListener mGraphControlListener = new View.OnClickListener()
{
@Override
public void onClick( View v )
{
int id = v.getId();
switch( id )
{
case R.id.graphtype_timespeed:
mViewFlipper.setDisplayedChild( 0 );
break;
case R.id.graphtype_distancespeed:
mViewFlipper.setDisplayedChild( 1 );
break;
case R.id.graphtype_timealtitude:
mViewFlipper.setDisplayedChild( 2 );
break;
case R.id.graphtype_distancealtitude:
mViewFlipper.setDisplayedChild( 3 );
break;
default:
break;
}
dismissDialog( DIALOG_GRAPHTYPE );
}
};
class MyGestureDetector extends SimpleOnGestureListener
{
@Override
public boolean onFling( MotionEvent e1, MotionEvent e2, float velocityX, float velocityY )
{
if( Math.abs( e1.getY() - e2.getY() ) > SWIPE_MAX_OFF_PATH )
return false;
// right to left swipe
if( e1.getX() - e2.getX() > SWIPE_MIN_DISTANCE && Math.abs( velocityX ) > SWIPE_THRESHOLD_VELOCITY )
{
mViewFlipper.setInAnimation( mSlideLeftIn );
mViewFlipper.setOutAnimation( mSlideLeftOut );
mViewFlipper.showNext();
}
else if( e2.getX() - e1.getX() > SWIPE_MIN_DISTANCE && Math.abs( velocityX ) > SWIPE_THRESHOLD_VELOCITY )
{
mViewFlipper.setInAnimation( mSlideRightIn );
mViewFlipper.setOutAnimation( mSlideRightOut );
mViewFlipper.showPrevious();
}
return false;
}
}
/**
* Called when the activity is first created.
*/
@Override
protected void onCreate( Bundle load )
{
super.onCreate( load );
mUnits = new UnitsI18n( this, new UnitsI18n.UnitsChangeListener()
{
@Override
public void onUnitsChange()
{
drawTrackingStatistics();
}
} );
setContentView( R.layout.statistics );
mViewFlipper = (ViewFlipper) findViewById( R.id.flipper );
mViewFlipper.setDrawingCacheEnabled(true);
mSlideLeftIn = AnimationUtils.loadAnimation( this, R.anim.slide_left_in );
mSlideLeftOut = AnimationUtils.loadAnimation( this, R.anim.slide_left_out );
mSlideRightIn = AnimationUtils.loadAnimation( this, R.anim.slide_right_in );
mSlideRightOut = AnimationUtils.loadAnimation( this, R.anim.slide_right_out );
mGraphTimeSpeed = (GraphCanvas) mViewFlipper.getChildAt( 0 );
mGraphDistanceSpeed = (GraphCanvas) mViewFlipper.getChildAt( 1 );
mGraphTimeAltitude = (GraphCanvas) mViewFlipper.getChildAt( 2 );
mGraphDistanceAltitude = (GraphCanvas) mViewFlipper.getChildAt( 3 );
mGraphTimeSpeed.setType( GraphCanvas.TIMESPEEDGRAPH );
mGraphDistanceSpeed.setType( GraphCanvas.DISTANCESPEEDGRAPH );
mGraphTimeAltitude.setType( GraphCanvas.TIMEALTITUDEGRAPH );
mGraphDistanceAltitude.setType( GraphCanvas.DISTANCEALTITUDEGRAPH );
mGestureDetector = new GestureDetector( new MyGestureDetector() );
maxSpeedView = (TextView) findViewById( R.id.stat_maximumspeed );
mAscensionView = (TextView) findViewById( R.id.stat_ascension );
mElapsedTimeView = (TextView) findViewById( R.id.stat_elapsedtime );
overallavgSpeedView = (TextView) findViewById( R.id.stat_overallaveragespeed );
avgSpeedView = (TextView) findViewById( R.id.stat_averagespeed );
distanceView = (TextView) findViewById( R.id.stat_distance );
starttimeView = (TextView) findViewById( R.id.stat_starttime );
endtimeView = (TextView) findViewById( R.id.stat_endtime );
waypointsView = (TextView) findViewById( R.id.stat_waypoints );
if( load != null && load.containsKey( TRACKURI ) )
{
mTrackUri = Uri.withAppendedPath( Tracks.CONTENT_URI, load.getString( TRACKURI ) );
}
else
{
mTrackUri = this.getIntent().getData();
}
}
@Override
protected void onRestoreInstanceState( Bundle load )
{
if( load != null )
{
super.onRestoreInstanceState( load );
}
if( load != null && load.containsKey( TRACKURI ) )
{
mTrackUri = Uri.withAppendedPath( Tracks.CONTENT_URI, load.getString( TRACKURI ) );
}
if( load != null && load.containsKey( "FLIP" ) )
{
mViewFlipper.setDisplayedChild( load.getInt( "FLIP" ) );
}
}
@Override
protected void onSaveInstanceState( Bundle save )
{
super.onSaveInstanceState( save );
save.putString( TRACKURI, mTrackUri.getLastPathSegment() );
save.putInt( "FLIP" , mViewFlipper.getDisplayedChild() );
}
/*
* (non-Javadoc)
* @see android.app.Activity#onPause()
*/
@Override
protected void onPause()
{
super.onPause();
mViewFlipper.stopFlipping();
mGraphTimeSpeed.clearData();
mGraphDistanceSpeed.clearData();
mGraphTimeAltitude.clearData();
mGraphDistanceAltitude.clearData();
ContentResolver resolver = this.getContentResolver();
resolver.unregisterContentObserver( this.mTrackObserver );
}
/*
* (non-Javadoc)
* @see android.app.Activity#onResume()
*/
@Override
protected void onResume()
{
super.onResume();
drawTrackingStatistics();
ContentResolver resolver = this.getContentResolver();
resolver.registerContentObserver( mTrackUri, true, this.mTrackObserver );
}
@Override
public boolean onCreateOptionsMenu( Menu menu )
{
boolean result = super.onCreateOptionsMenu( menu );
menu.add( ContextMenu.NONE, MENU_GRAPHTYPE, ContextMenu.NONE, R.string.menu_graphtype ).setIcon( R.drawable.ic_menu_picture ).setAlphabeticShortcut( 't' );
menu.add( ContextMenu.NONE, MENU_TRACKLIST, ContextMenu.NONE, R.string.menu_tracklist ).setIcon( R.drawable.ic_menu_show_list ).setAlphabeticShortcut( 'l' );
menu.add( ContextMenu.NONE, MENU_SHARE, ContextMenu.NONE, R.string.menu_shareTrack ).setIcon( R.drawable.ic_menu_share ).setAlphabeticShortcut( 's' );
return result;
}
@Override
public boolean onOptionsItemSelected( MenuItem item )
{
boolean handled = false;
Intent intent;
switch( item.getItemId() )
{
case MENU_GRAPHTYPE:
showDialog( DIALOG_GRAPHTYPE );
handled = true;
break;
case MENU_TRACKLIST:
intent = new Intent( this, TrackList.class );
intent.putExtra( Tracks._ID, mTrackUri.getLastPathSegment() );
startActivityForResult( intent, MENU_TRACKLIST );
break;
case MENU_SHARE:
intent = new Intent( Intent.ACTION_RUN );
intent.setDataAndType( mTrackUri, Tracks.CONTENT_ITEM_TYPE );
intent.addFlags( Intent.FLAG_GRANT_READ_URI_PERMISSION );
Bitmap bm = mViewFlipper.getDrawingCache();
Uri screenStreamUri = ShareTrack.storeScreenBitmap(bm);
intent.putExtra(Intent.EXTRA_STREAM, screenStreamUri);
startActivityForResult(Intent.createChooser( intent, getString( R.string.share_track ) ), MENU_SHARE);
handled = true;
break;
default:
handled = super.onOptionsItemSelected( item );
}
return handled;
}
@Override
public boolean onTouchEvent( MotionEvent event )
{
if( mGestureDetector.onTouchEvent( event ) )
return true;
else
return false;
}
/*
* (non-Javadoc)
* @see android.app.Activity#onActivityResult(int, int, android.content.Intent)
*/
@Override
protected void onActivityResult( int requestCode, int resultCode, Intent intent )
{
super.onActivityResult( requestCode, resultCode, intent );
switch( requestCode )
{
case MENU_TRACKLIST:
if( resultCode == RESULT_OK )
{
mTrackUri = intent.getData();
drawTrackingStatistics();
}
break;
case MENU_SHARE:
ShareTrack.clearScreenBitmap();
break;
default:
Log.w( TAG, "Unknown activity result request code" );
}
}
/*
* (non-Javadoc)
* @see android.app.Activity#onCreateDialog(int)
*/
@Override
protected Dialog onCreateDialog( int id )
{
Dialog dialog = null;
LayoutInflater factory = null;
View view = null;
Builder builder = null;
switch( id )
{
case DIALOG_GRAPHTYPE:
builder = new AlertDialog.Builder( this );
factory = LayoutInflater.from( this );
view = factory.inflate( R.layout.graphtype, null );
builder.setTitle( R.string.dialog_graphtype_title ).setIcon( android.R.drawable.ic_dialog_alert ).setNegativeButton( R.string.btn_cancel, null ).setView( view );
dialog = builder.create();
return dialog;
default:
return super.onCreateDialog( id );
}
}
/*
* (non-Javadoc)
* @see android.app.Activity#onPrepareDialog(int, android.app.Dialog)
*/
@Override
protected void onPrepareDialog( int id, Dialog dialog )
{
switch( id )
{
case DIALOG_GRAPHTYPE:
Button speedtime = (Button) dialog.findViewById( R.id.graphtype_timespeed );
Button speeddistance = (Button) dialog.findViewById( R.id.graphtype_distancespeed );
Button altitudetime = (Button) dialog.findViewById( R.id.graphtype_timealtitude );
Button altitudedistance = (Button) dialog.findViewById( R.id.graphtype_distancealtitude );
speedtime.setOnClickListener( mGraphControlListener );
speeddistance.setOnClickListener( mGraphControlListener );
altitudetime.setOnClickListener( mGraphControlListener );
altitudedistance.setOnClickListener( mGraphControlListener );
default:
break;
}
super.onPrepareDialog( id, dialog );
}
private void drawTrackingStatistics()
{
calculating = true;
StatisticsCalulator calculator = new StatisticsCalulator( this, mUnits, this );
calculator.execute(mTrackUri);
}
@Override
public void finishedCalculations(StatisticsCalulator calculated)
{
mGraphTimeSpeed.setData ( mTrackUri, calculated );
mGraphDistanceSpeed.setData ( mTrackUri, calculated );
mGraphTimeAltitude.setData ( mTrackUri, calculated );
mGraphDistanceAltitude.setData( mTrackUri, calculated );
mViewFlipper.postInvalidate();
maxSpeedView.setText( calculated.getMaxSpeedText() );
mElapsedTimeView.setText( calculated.getDurationText() );
mAscensionView.setText( calculated.getAscensionText() );
overallavgSpeedView.setText( calculated.getOverallavgSpeedText() );
avgSpeedView.setText( calculated.getAvgSpeedText() );
distanceView.setText( calculated.getDistanceText() );
starttimeView.setText( Long.toString( calculated.getStarttime() ) );
endtimeView.setText( Long.toString( calculated.getEndtime() ) );
String titleFormat = getString( R.string.stat_title );
setTitle( String.format( titleFormat, calculated.getTracknameText() ) );
waypointsView.setText( calculated.getWaypointsText() );
calculating = false;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/Statistics.java | Java | gpl3 | 16,232 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions;
import java.util.Calendar;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnDismissListener;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.EditText;
/**
* Empty Activity that pops up the dialog to name the track
*
* @version $Id$
* @author rene (c) Jul 27, 2010, Sogeti B.V.
*/
public class NameTrack extends Activity
{
private static final int DIALOG_TRACKNAME = 23;
protected static final String TAG = "OGT.NameTrack";
private EditText mTrackNameView;
private boolean paused;
Uri mTrackUri;
private final DialogInterface.OnClickListener mTrackNameDialogListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick( DialogInterface dialog, int which )
{
String trackName = null;
switch( which )
{
case DialogInterface.BUTTON_POSITIVE:
trackName = mTrackNameView.getText().toString();
ContentValues values = new ContentValues();
values.put( Tracks.NAME, trackName );
getContentResolver().update( mTrackUri, values, null, null );
clearNotification();
break;
case DialogInterface.BUTTON_NEUTRAL:
startDelayNotification();
break;
case DialogInterface.BUTTON_NEGATIVE:
clearNotification();
break;
default:
Log.e( TAG, "Unknown option ending dialog:"+which );
break;
}
finish();
}
};
private void clearNotification()
{
NotificationManager noticationManager = (NotificationManager) this.getSystemService( Context.NOTIFICATION_SERVICE );;
noticationManager.cancel( R.layout.namedialog );
}
private void startDelayNotification()
{
int resId = R.string.dialog_routename_title;
int icon = R.drawable.ic_maps_indicator_current_position;
CharSequence tickerText = getResources().getString( resId );
long when = System.currentTimeMillis();
Notification nameNotification = new Notification( icon, tickerText, when );
nameNotification.flags |= Notification.FLAG_AUTO_CANCEL;
CharSequence contentTitle = getResources().getString( R.string.app_name );
CharSequence contentText = getResources().getString( resId );
Intent notificationIntent = new Intent( this, NameTrack.class );
notificationIntent.setData( mTrackUri );
PendingIntent contentIntent = PendingIntent.getActivity( this, 0, notificationIntent, Intent.FLAG_ACTIVITY_NEW_TASK );
nameNotification.setLatestEventInfo( this, contentTitle, contentText, contentIntent );
NotificationManager noticationManager = (NotificationManager) this.getSystemService( Context.NOTIFICATION_SERVICE );
noticationManager.notify( R.layout.namedialog, nameNotification );
}
@Override
protected void onCreate( Bundle savedInstanceState )
{
super.onCreate( savedInstanceState );
this.setVisible( false );
paused = false;
mTrackUri = this.getIntent().getData();
}
@Override
protected void onPause()
{
super.onPause();
paused = true;
}
/*
* (non-Javadoc)
* @see com.google.android.maps.MapActivity#onPause()
*/
@Override
protected void onResume()
{
super.onResume();
if( mTrackUri != null )
{
showDialog( DIALOG_TRACKNAME );
}
else
{
Log.e(TAG, "Naming track without a track URI supplied." );
finish();
}
}
@Override
protected Dialog onCreateDialog( int id )
{
Dialog dialog = null;
LayoutInflater factory = null;
View view = null;
Builder builder = null;
switch (id)
{
case DIALOG_TRACKNAME:
builder = new AlertDialog.Builder( this );
factory = LayoutInflater.from( this );
view = factory.inflate( R.layout.namedialog, null );
mTrackNameView = (EditText) view.findViewById( R.id.nameField );
builder
.setTitle( R.string.dialog_routename_title )
.setMessage( R.string.dialog_routename_message )
.setIcon( android.R.drawable.ic_dialog_alert )
.setPositiveButton( R.string.btn_okay, mTrackNameDialogListener )
.setNeutralButton( R.string.btn_skip, mTrackNameDialogListener )
.setNegativeButton( R.string.btn_cancel, mTrackNameDialogListener )
.setView( view );
dialog = builder.create();
dialog.setOnDismissListener( new OnDismissListener()
{
@Override
public void onDismiss( DialogInterface dialog )
{
if( !paused )
{
finish();
}
}
});
return dialog;
default:
return super.onCreateDialog( id );
}
}
@Override
protected void onPrepareDialog( int id, Dialog dialog )
{
switch (id)
{
case DIALOG_TRACKNAME:
String trackName;
Calendar c = Calendar.getInstance();
trackName = String.format( getString( R.string.dialog_routename_default ), c, c, c, c, c );
mTrackNameView.setText( trackName );
mTrackNameView.setSelection( 0, trackName.length() );
break;
default:
super.onPrepareDialog( id, dialog );
break;
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/NameTrack.java | Java | gpl3 | 7,765 |
package nl.sogeti.android.gpstracker.actions.utils;
public interface StatisticsDelegate
{
void finishedCalculations(StatisticsCalulator calculated);
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/utils/StatisticsDelegate.java | Java | gpl3 | 154 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.utils;
import android.app.Activity;
import android.net.Uri;
/**
* Interface to which a Activity / Context can conform to receive progress
* updates from async tasks
*
* @version $Id:$
* @author rene (c) May 29, 2011, Sogeti B.V.
*/
public interface ProgressListener
{
void setIndeterminate(boolean indeterminate);
/**
* Signifies the start of background task, will be followed by setProgress(int) calls.
*/
void started();
/**
* Set the progress on the scale of 0...10000
*
* @param value
*
* @see Activity.setProgress
* @see Window.PROGRESS_END
*/
void setProgress(int value);
/**
* Signifies end of background task and the location of the result
*
* @param result
*/
void finished(Uri result);
void showError(String task, String errorMessage, Exception exception);
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/utils/ProgressListener.java | Java | gpl3 | 2,432 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.utils;
import nl.sogeti.android.gpstracker.db.GPStracking.Segments;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.UnitsI18n;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.location.Location;
import android.net.Uri;
import android.os.AsyncTask;
public class StatisticsCalulator extends AsyncTask<Uri, Void, Void>
{
@SuppressWarnings("unused")
private static final String TAG = "OGT.StatisticsCalulator";
private Context mContext;
private String overallavgSpeedText = "Unknown";
private String avgSpeedText = "Unknown";
private String maxSpeedText = "Unknown";
private String ascensionText = "Unknown";
private String minSpeedText = "Unknown";
private String tracknameText = "Unknown";
private String waypointsText = "Unknown";
private String distanceText = "Unknown";
private long mStarttime = -1;
private long mEndtime = -1;
private UnitsI18n mUnits;
private double mMaxSpeed;
private double mMaxAltitude;
private double mMinAltitude;
private double mAscension;
private double mDistanceTraveled;
private long mDuration;
private double mAverageActiveSpeed;
private StatisticsDelegate mDelegate;
public StatisticsCalulator( Context ctx, UnitsI18n units, StatisticsDelegate delegate )
{
mContext = ctx;
mUnits = units;
mDelegate = delegate;
}
private void updateCalculations( Uri trackUri )
{
mStarttime = -1;
mEndtime = -1;
mMaxSpeed = 0;
mAverageActiveSpeed = 0;
mMaxAltitude = 0;
mMinAltitude = 0;
mAscension = 0;
mDistanceTraveled = 0f;
mDuration = 0;
long duration = 1;
double ascension = 0;
ContentResolver resolver = mContext.getContentResolver();
Cursor waypointsCursor = null;
try
{
waypointsCursor = resolver.query(
Uri.withAppendedPath( trackUri, "waypoints" ),
new String[] { "max (" + Waypoints.TABLE + "." + Waypoints.SPEED + ")"
, "max (" + Waypoints.TABLE + "." + Waypoints.ALTITUDE + ")"
, "min (" + Waypoints.TABLE + "." + Waypoints.ALTITUDE + ")"
, "count(" + Waypoints.TABLE + "." + Waypoints._ID + ")" },
null, null, null );
if( waypointsCursor.moveToLast() )
{
mMaxSpeed = waypointsCursor.getDouble( 0 );
mMaxAltitude = waypointsCursor.getDouble( 1 );
mMinAltitude = waypointsCursor.getDouble( 2 );
long nrWaypoints = waypointsCursor.getLong( 3 );
waypointsText = nrWaypoints + "";
}
waypointsCursor.close();
waypointsCursor = resolver.query(
Uri.withAppendedPath( trackUri, "waypoints" ),
new String[] { "avg (" + Waypoints.TABLE + "." + Waypoints.SPEED + ")" },
Waypoints.TABLE + "." + Waypoints.SPEED +" > ?",
new String[] { ""+Constants.MIN_STATISTICS_SPEED },
null );
if( waypointsCursor.moveToLast() )
{
mAverageActiveSpeed = waypointsCursor.getDouble( 0 );
}
}
finally
{
if( waypointsCursor != null )
{
waypointsCursor.close();
}
}
Cursor trackCursor = null;
try
{
trackCursor = resolver.query( trackUri, new String[] { Tracks.NAME }, null, null, null );
if( trackCursor.moveToLast() )
{
tracknameText = trackCursor.getString( 0 );
}
}
finally
{
if( trackCursor != null )
{
trackCursor.close();
}
}
Cursor segments = null;
Location lastLocation = null;
Location lastAltitudeLocation = null;
Location currentLocation = null;
try
{
Uri segmentsUri = Uri.withAppendedPath( trackUri, "segments" );
segments = resolver.query( segmentsUri, new String[] { Segments._ID }, null, null, null );
if( segments.moveToFirst() )
{
do
{
long segmentsId = segments.getLong( 0 );
Cursor waypoints = null;
try
{
Uri waypointsUri = Uri.withAppendedPath( segmentsUri, segmentsId + "/waypoints" );
waypoints = resolver.query( waypointsUri, new String[] { Waypoints._ID, Waypoints.TIME, Waypoints.LONGITUDE, Waypoints.LATITUDE, Waypoints.ALTITUDE }, null, null, null );
if( waypoints.moveToFirst() )
{
do
{
if( mStarttime < 0 )
{
mStarttime = waypoints.getLong( 1 );
}
currentLocation = new Location( this.getClass().getName() );
currentLocation.setTime( waypoints.getLong( 1 ) );
currentLocation.setLongitude( waypoints.getDouble( 2 ) );
currentLocation.setLatitude( waypoints.getDouble( 3 ) );
currentLocation.setAltitude( waypoints.getDouble( 4 ) );
// Do no include obvious wrong 0.0 lat 0.0 long, skip to next value in while-loop
if( currentLocation.getLatitude() == 0.0d || currentLocation.getLongitude() == 0.0d )
{
continue;
}
if( lastLocation != null )
{
float travelPart = lastLocation.distanceTo( currentLocation );
long timePart = currentLocation.getTime() - lastLocation.getTime();
mDistanceTraveled += travelPart;
duration += timePart;
}
if( currentLocation.hasAltitude() )
{
if( lastAltitudeLocation != null )
{
if( currentLocation.getTime() - lastAltitudeLocation.getTime() > 5*60*1000 ) // more then a 5m of climbing
{
if( currentLocation.getAltitude() > lastAltitudeLocation.getAltitude()+1 ) // more then 1m climb
{
ascension += currentLocation.getAltitude() - lastAltitudeLocation.getAltitude();
lastAltitudeLocation = currentLocation;
}
else
{
lastAltitudeLocation = currentLocation;
}
}
}
else
{
lastAltitudeLocation = currentLocation;
}
}
lastLocation = currentLocation;
mEndtime = lastLocation.getTime();
}
while( waypoints.moveToNext() );
mDuration = mEndtime - mStarttime;
}
}
finally
{
if( waypoints != null )
{
waypoints.close();
}
}
lastLocation = null;
}
while( segments.moveToNext() );
}
}
finally
{
if( segments != null )
{
segments.close();
}
}
double maxSpeed = mUnits.conversionFromMetersPerSecond( mMaxSpeed );
double overallavgSpeedfl = mUnits.conversionFromMeterAndMiliseconds( mDistanceTraveled, mDuration );
double avgSpeedfl = mUnits.conversionFromMeterAndMiliseconds( mDistanceTraveled, duration );
double traveled = mUnits.conversionFromMeter( mDistanceTraveled );
avgSpeedText = mUnits.formatSpeed( avgSpeedfl, true );
overallavgSpeedText = mUnits.formatSpeed( overallavgSpeedfl, true );
maxSpeedText = mUnits.formatSpeed( maxSpeed, true );
distanceText = String.format( "%.2f %s", traveled, mUnits.getDistanceUnit() );
ascensionText = String.format( "%.0f %s", ascension, mUnits.getHeightUnit() );
}
/**
* Get the overallavgSpeedText.
*
* @return Returns the overallavgSpeedText as a String.
*/
public String getOverallavgSpeedText()
{
return overallavgSpeedText;
}
/**
* Get the avgSpeedText.
*
* @return Returns the avgSpeedText as a String.
*/
public String getAvgSpeedText()
{
return avgSpeedText;
}
/**
* Get the maxSpeedText.
*
* @return Returns the maxSpeedText as a String.
*/
public String getMaxSpeedText()
{
return maxSpeedText;
}
/**
* Get the minSpeedText.
*
* @return Returns the minSpeedText as a String.
*/
public String getMinSpeedText()
{
return minSpeedText;
}
/**
* Get the tracknameText.
*
* @return Returns the tracknameText as a String.
*/
public String getTracknameText()
{
return tracknameText;
}
/**
* Get the waypointsText.
*
* @return Returns the waypointsText as a String.
*/
public String getWaypointsText()
{
return waypointsText;
}
/**
* Get the distanceText.
*
* @return Returns the distanceText as a String.
*/
public String getDistanceText()
{
return distanceText;
}
/**
* Get the starttime.
*
* @return Returns the starttime as a long.
*/
public long getStarttime()
{
return mStarttime;
}
/**
* Get the endtime.
*
* @return Returns the endtime as a long.
*/
public long getEndtime()
{
return mEndtime;
}
/**
* Get the maximum speed.
*
* @return Returns the maxSpeeddb as m/s in a double.
*/
public double getMaxSpeed()
{
return mMaxSpeed;
}
/**
* Get the min speed.
*
* @return Returns the average speed as m/s in a double.
*/
public double getAverageStatisicsSpeed()
{
return mAverageActiveSpeed;
}
/**
* Get the maxAltitude.
*
* @return Returns the maxAltitude as a double.
*/
public double getMaxAltitude()
{
return mMaxAltitude;
}
/**
* Get the minAltitude.
*
* @return Returns the minAltitude as a double.
*/
public double getMinAltitude()
{
return mMinAltitude;
}
/**
* Get the total ascension in m.
*
* @return Returns the ascension as a double.
*/
public double getAscension()
{
return mAscension;
}
public CharSequence getAscensionText()
{
return ascensionText;
}
/**
* Get the distanceTraveled.
*
* @return Returns the distanceTraveled as a float.
*/
public double getDistanceTraveled()
{
return mDistanceTraveled;
}
/**
* Get the mUnits.
*
* @return Returns the mUnits as a UnitsI18n.
*/
public UnitsI18n getUnits()
{
return mUnits;
}
public String getDurationText()
{
long s = mDuration / 1000;
String duration = String.format("%dh:%02dm:%02ds", s/3600, (s%3600)/60, (s%60));
return duration;
}
@Override
protected Void doInBackground(Uri... params)
{
this.updateCalculations(params[0]);
return null;
}
@Override
protected void onPostExecute(Void result)
{
super.onPostExecute(result);
if( mDelegate != null )
{
mDelegate.finishedCalculations(this);
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/utils/StatisticsCalulator.java | Java | gpl3 | 13,828 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.utils;
import java.text.DateFormat;
import java.util.Date;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.db.GPStracking.Segments;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.UnitsI18n;
import android.content.ContentResolver;
import android.content.Context;
import android.content.res.Resources;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.CornerPathEffect;
import android.graphics.DashPathEffect;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Typeface;
import android.location.Location;
import android.net.Uri;
import android.util.AttributeSet;
import android.view.View;
/**
* Calculate and draw graphs of track data
*
* @version $Id$
* @author rene (c) Mar 22, 2009, Sogeti B.V.
*/
public class GraphCanvas extends View
{
@SuppressWarnings("unused")
private static final String TAG = "OGT.GraphCanvas";
public static final int TIMESPEEDGRAPH = 0;
public static final int DISTANCESPEEDGRAPH = 1;
public static final int TIMEALTITUDEGRAPH = 2;
public static final int DISTANCEALTITUDEGRAPH = 3;
private Uri mUri;
private Bitmap mRenderBuffer;
private Canvas mRenderCanvas;
private Context mContext;
private UnitsI18n mUnits;
private int mGraphType = -1;
private long mEndTime;
private long mStartTime;
private double mDistance;
private int mHeight;
private int mWidth;
private int mMinAxis;
private int mMaxAxis;
private double mMinAlititude;
private double mMaxAlititude;
private double mHighestSpeedNumber;
private double mDistanceDrawn;
private long mStartTimeDrawn;
private long mEndTimeDrawn;
float density = Resources.getSystem().getDisplayMetrics().density;
private Paint whiteText ;
private Paint ltgreyMatrixDashed;
private Paint greenGraphLine;
private Paint dkgreyMatrixLine;
private Paint whiteCenteredText;
private Paint dkgrayLargeType;
public GraphCanvas( Context context, AttributeSet attrs )
{
this(context, attrs, 0);
}
public GraphCanvas( Context context, AttributeSet attrs, int defStyle )
{
super(context, attrs, defStyle);
mContext = context;
whiteText = new Paint();
whiteText.setColor( Color.WHITE );
whiteText.setAntiAlias( true );
whiteText.setTextSize( (int)(density * 12) );
whiteCenteredText = new Paint();
whiteCenteredText.setColor( Color.WHITE );
whiteCenteredText.setAntiAlias( true );
whiteCenteredText.setTextAlign( Paint.Align.CENTER );
whiteCenteredText.setTextSize( (int)(density * 12) );
ltgreyMatrixDashed = new Paint();
ltgreyMatrixDashed.setColor( Color.LTGRAY );
ltgreyMatrixDashed.setStrokeWidth( 1 );
ltgreyMatrixDashed.setPathEffect( new DashPathEffect( new float[]{2,4}, 0 ) );
greenGraphLine = new Paint();
greenGraphLine.setPathEffect( new CornerPathEffect( 8 ) );
greenGraphLine.setStyle( Paint.Style.STROKE );
greenGraphLine.setStrokeWidth( 4 );
greenGraphLine.setAntiAlias( true );
greenGraphLine.setColor(Color.GREEN);
dkgreyMatrixLine = new Paint();
dkgreyMatrixLine.setColor( Color.DKGRAY );
dkgreyMatrixLine.setStrokeWidth( 2 );
dkgrayLargeType = new Paint();
dkgrayLargeType.setColor( Color.LTGRAY );
dkgrayLargeType.setAntiAlias( true );
dkgrayLargeType.setTextAlign( Paint.Align.CENTER );
dkgrayLargeType.setTextSize( (int)(density * 21) );
dkgrayLargeType.setTypeface( Typeface.DEFAULT_BOLD );
}
/**
* Set the dataset for which to draw data. Also provide hints and helpers.
*
* @param uri
* @param startTime
* @param endTime
* @param distance
* @param minAlititude
* @param maxAlititude
* @param maxSpeed
* @param units
*/
public void setData( Uri uri, StatisticsCalulator calc )
{
boolean rerender = false;
if( uri.equals( mUri ) )
{
double distanceDrawnPercentage = mDistanceDrawn / mDistance;
double duractionDrawnPercentage = (double)((1d+mEndTimeDrawn-mStartTimeDrawn) / (1d+mEndTime-mStartTime));
rerender = distanceDrawnPercentage < 0.99d || duractionDrawnPercentage < 0.99d;
}
else
{
if( mRenderBuffer == null && super.getWidth() > 0 && super.getHeight() > 0 )
{
initRenderBuffer(super.getWidth(), super.getHeight());
}
rerender = true;
}
mUri = uri;
mUnits = calc.getUnits();
mMinAlititude = mUnits.conversionFromMeterToHeight( calc.getMinAltitude() );
mMaxAlititude = mUnits.conversionFromMeterToHeight( calc.getMaxAltitude() );
if( mUnits.isUnitFlipped() )
{
mHighestSpeedNumber = 1.5 * mUnits.conversionFromMetersPerSecond( calc.getAverageStatisicsSpeed() );
}
else
{
mHighestSpeedNumber = mUnits.conversionFromMetersPerSecond( calc.getMaxSpeed() );
}
mStartTime = calc.getStarttime();
mEndTime = calc.getEndtime();
mDistance = calc.getDistanceTraveled();
if( rerender )
{
renderGraph();
}
}
public synchronized void clearData()
{
mUri = null;
mUnits = null;
mRenderBuffer = null;
}
public void setType( int graphType)
{
if( mGraphType != graphType )
{
mGraphType = graphType;
renderGraph();
}
}
public int getType()
{
return mGraphType;
}
@Override
protected synchronized void onSizeChanged( int w, int h, int oldw, int oldh )
{
super.onSizeChanged( w, h, oldw, oldh );
initRenderBuffer(w, h);
renderGraph();
}
private void initRenderBuffer(int w, int h)
{
mRenderBuffer = Bitmap.createBitmap( w, h, Config.ARGB_8888 );
mRenderCanvas = new Canvas( mRenderBuffer );
}
@Override
protected synchronized void onDraw( Canvas canvas )
{
super.onDraw(canvas);
if( mRenderBuffer != null )
{
canvas.drawBitmap( mRenderBuffer, 0, 0, null );
}
}
private synchronized void renderGraph()
{
if( mRenderBuffer != null && mUri != null )
{
mRenderBuffer.eraseColor( Color.TRANSPARENT );
switch( mGraphType )
{
case( TIMESPEEDGRAPH ):
setupSpeedAxis();
drawGraphType();
drawTimeAxisGraphOnCanvas( new String[] { Waypoints.TIME, Waypoints.SPEED }, Constants.MIN_STATISTICS_SPEED );
drawSpeedsTexts();
drawTimeTexts();
break;
case( DISTANCESPEEDGRAPH ):
setupSpeedAxis();
drawGraphType();
drawDistanceAxisGraphOnCanvas( new String[] { Waypoints.LONGITUDE, Waypoints.LATITUDE, Waypoints.SPEED }, Constants.MIN_STATISTICS_SPEED );
drawSpeedsTexts();
drawDistanceTexts();
break;
case( TIMEALTITUDEGRAPH ):
setupAltitudeAxis();
drawGraphType();
drawTimeAxisGraphOnCanvas( new String[] { Waypoints.TIME, Waypoints.ALTITUDE }, -1000d );
drawAltitudesTexts();
drawTimeTexts();
break;
case( DISTANCEALTITUDEGRAPH ):
setupAltitudeAxis();
drawGraphType();
drawDistanceAxisGraphOnCanvas( new String[] { Waypoints.LONGITUDE, Waypoints.LATITUDE, Waypoints.ALTITUDE }, -1000d );
drawAltitudesTexts();
drawDistanceTexts();
break;
default:
break;
}
mDistanceDrawn = mDistance;
mStartTimeDrawn = mStartTime;
mEndTimeDrawn = mEndTime;
}
postInvalidate();
}
/**
*
* @param params
* @param minValue Minimum value of params[1] that will be drawn
*/
private void drawDistanceAxisGraphOnCanvas( String[] params, double minValue )
{
ContentResolver resolver = mContext.getContentResolver();
Uri segmentsUri = Uri.withAppendedPath( mUri, "segments" );
Uri waypointsUri = null;
Cursor segments = null;
Cursor waypoints = null;
double[][] values ;
int[][] valueDepth;
double distance = 1;
try
{
segments = resolver.query(
segmentsUri,
new String[]{ Segments._ID },
null, null, null );
int segmentCount = segments.getCount();
values = new double[segmentCount][mWidth];
valueDepth = new int[segmentCount][mWidth];
if( segments.moveToFirst() )
{
for(int segment=0;segment<segmentCount;segment++)
{
segments.moveToPosition( segment );
long segmentId = segments.getLong( 0 );
waypointsUri = Uri.withAppendedPath( segmentsUri, segmentId+"/waypoints" );
try
{
waypoints = resolver.query(
waypointsUri,
params,
null, null, null );
if( waypoints.moveToFirst() )
{
Location lastLocation = null;
Location currentLocation = null;
do
{
currentLocation = new Location( this.getClass().getName() );
currentLocation.setLongitude( waypoints.getDouble( 0 ) );
currentLocation.setLatitude( waypoints.getDouble( 1 ) );
// Do no include obvious wrong 0.0 lat 0.0 long, skip to next value in while-loop
if( currentLocation.getLatitude() == 0.0d || currentLocation.getLongitude() == 0.0d )
{
continue;
}
if( lastLocation != null )
{
distance += lastLocation.distanceTo( currentLocation );
}
lastLocation = currentLocation;
double value = waypoints.getDouble( 2 );
if( value != 0 && value > minValue && segment < values.length )
{
int x = (int) ((distance)*(mWidth-1) / mDistance);
if( x > 0 && x < valueDepth[segment].length )
{
valueDepth[segment][x]++;
values[segment][x] = values[segment][x]+((value-values[segment][x])/valueDepth[segment][x]);
}
}
}
while( waypoints.moveToNext() );
}
}
finally
{
if( waypoints != null )
{
waypoints.close();
}
}
}
}
}
finally
{
if( segments != null )
{
segments.close();
}
}
for( int segment=0;segment<values.length;segment++)
{
for( int x=0;x<values[segment].length;x++)
{
if( valueDepth[segment][x] > 0 )
{
values[segment][x] = translateValue( values[segment][x] );
}
}
}
drawGraph( values, valueDepth );
}
private void drawTimeAxisGraphOnCanvas( String[] params, double minValue )
{
ContentResolver resolver = mContext.getContentResolver();
Uri segmentsUri = Uri.withAppendedPath( mUri, "segments" );
Uri waypointsUri = null;
Cursor segments = null;
Cursor waypoints = null;
long duration = 1+mEndTime - mStartTime;
double[][] values ;
int[][] valueDepth;
try
{
segments = resolver.query(
segmentsUri,
new String[]{ Segments._ID },
null, null, null );
int segmentCount = segments.getCount();
values = new double[segmentCount][mWidth];
valueDepth = new int[segmentCount][mWidth];
if( segments.moveToFirst() )
{
for(int segment=0;segment<segmentCount;segment++)
{
segments.moveToPosition( segment );
long segmentId = segments.getLong( 0 );
waypointsUri = Uri.withAppendedPath( segmentsUri, segmentId+"/waypoints" );
try
{
waypoints = resolver.query(
waypointsUri,
params,
null, null, null );
if( waypoints.moveToFirst() )
{
do
{
long time = waypoints.getLong( 0 );
double value = waypoints.getDouble( 1 );
if( value != 0 && value > minValue && segment < values.length )
{
int x = (int) ((time-mStartTime)*(mWidth-1) / duration);
if( x > 0 && x < valueDepth[segment].length )
{
valueDepth[segment][x]++;
values[segment][x] = values[segment][x]+((value-values[segment][x])/valueDepth[segment][x]);
}
}
}
while( waypoints.moveToNext() );
}
}
finally
{
if( waypoints != null )
{
waypoints.close();
}
}
}
}
}
finally
{
if( segments != null )
{
segments.close();
}
}
for( int p=0;p<values.length;p++)
{
for( int x=0;x<values[p].length;x++)
{
if( valueDepth[p][x] > 0 )
{
values[p][x] = translateValue( values[p][x] );
}
}
}
drawGraph( values, valueDepth );
}
private void setupAltitudeAxis()
{
mMinAxis = -4 + 4 * (int)(mMinAlititude / 4);
mMaxAxis = 4 + 4 * (int)(mMaxAlititude / 4);
mWidth = mRenderCanvas.getWidth()-5;
mHeight = mRenderCanvas.getHeight()-10;
}
private void setupSpeedAxis()
{
mMinAxis = 0;
mMaxAxis = 4 + 4 * (int)( mHighestSpeedNumber / 4);
mWidth = mRenderCanvas.getWidth()-5;
mHeight = mRenderCanvas.getHeight()-10;
}
private void drawAltitudesTexts()
{
mRenderCanvas.drawText( String.format( "%d %s", mMinAxis, mUnits.getHeightUnit() ) , 8, mHeight, whiteText );
mRenderCanvas.drawText( String.format( "%d %s", (mMaxAxis+mMinAxis)/2, mUnits.getHeightUnit() ) , 8, 5+mHeight/2, whiteText );
mRenderCanvas.drawText( String.format( "%d %s", mMaxAxis, mUnits.getHeightUnit() ), 8, 15, whiteText );
}
private void drawSpeedsTexts()
{
mRenderCanvas.drawText( String.format( "%d %s", mMinAxis, mUnits.getSpeedUnit() ) , 8, mHeight, whiteText );
mRenderCanvas.drawText( String.format( "%d %s", (mMaxAxis+mMinAxis)/2, mUnits.getSpeedUnit() ) , 8, 3+mHeight/2, whiteText );
mRenderCanvas.drawText( String.format( "%d %s", mMaxAxis, mUnits.getSpeedUnit() ) , 8, 7+whiteText.getTextSize(), whiteText );
}
private void drawGraphType()
{
//float density = Resources.getSystem().getDisplayMetrics().density;
String text;
switch( mGraphType )
{
case( TIMESPEEDGRAPH ):
text = mContext.getResources().getString( R.string.graphtype_timespeed );
break;
case( DISTANCESPEEDGRAPH ):
text = mContext.getResources().getString( R.string.graphtype_distancespeed );
break;
case( TIMEALTITUDEGRAPH ):
text = mContext.getResources().getString( R.string.graphtype_timealtitude );
break;
case( DISTANCEALTITUDEGRAPH ):
text = mContext.getResources().getString( R.string.graphtype_distancealtitude );
break;
default:
text = "UNKNOWN GRAPH TYPE";
break;
}
mRenderCanvas.drawText( text, 5+mWidth/2, 5+mHeight/8, dkgrayLargeType );
}
private void drawTimeTexts()
{
DateFormat timeInstance = android.text.format.DateFormat.getTimeFormat(this.getContext().getApplicationContext());
String start = timeInstance.format( new Date( mStartTime ) );
String half = timeInstance.format( new Date( (mEndTime+mStartTime)/2 ) );
String end = timeInstance.format( new Date( mEndTime ) );
Path yAxis;
yAxis = new Path();
yAxis.moveTo( 5, 5+mHeight/2 );
yAxis.lineTo( 5, 5 );
mRenderCanvas.drawTextOnPath( String.format( start ), yAxis, 0, whiteCenteredText.getTextSize(), whiteCenteredText );
yAxis = new Path();
yAxis.moveTo( 5+mWidth/2 , 5+mHeight/2 );
yAxis.lineTo( 5+mWidth/2 , 5 );
mRenderCanvas.drawTextOnPath( String.format( half ), yAxis, 0, -3, whiteCenteredText );
yAxis = new Path();
yAxis.moveTo( 5+mWidth-1 , 5+mHeight/2 );
yAxis.lineTo( 5+mWidth-1 , 5 );
mRenderCanvas.drawTextOnPath( String.format( end ), yAxis, 0, -3, whiteCenteredText );
}
private void drawDistanceTexts()
{
String start = String.format( "%.0f %s", mUnits.conversionFromMeter(0), mUnits.getDistanceUnit() ) ;
String half = String.format( "%.0f %s", mUnits.conversionFromMeter(mDistance)/2, mUnits.getDistanceUnit() ) ;
String end = String.format( "%.0f %s", mUnits.conversionFromMeter(mDistance) , mUnits.getDistanceUnit() ) ;
Path yAxis;
yAxis = new Path();
yAxis.moveTo( 5, 5+mHeight/2 );
yAxis.lineTo( 5, 5 );
mRenderCanvas.drawTextOnPath( String.format( start ), yAxis, 0, whiteText.getTextSize(), whiteCenteredText );
yAxis = new Path();
yAxis.moveTo( 5+mWidth/2 , 5+mHeight/2 );
yAxis.lineTo( 5+mWidth/2 , 5 );
mRenderCanvas.drawTextOnPath( String.format( half ), yAxis, 0, -3, whiteCenteredText );
yAxis = new Path();
yAxis.moveTo( 5+mWidth-1 , 5+mHeight/2 );
yAxis.lineTo( 5+mWidth-1 , 5 );
mRenderCanvas.drawTextOnPath( String.format( end ), yAxis, 0, -3, whiteCenteredText );
}
private double translateValue( double val )
{
switch( mGraphType )
{
case( TIMESPEEDGRAPH ):
case( DISTANCESPEEDGRAPH ):
val = mUnits.conversionFromMetersPerSecond( val );
break;
case( TIMEALTITUDEGRAPH ):
case( DISTANCEALTITUDEGRAPH ):
val = mUnits.conversionFromMeterToHeight( val );
break;
default:
break;
}
return val;
}
private void drawGraph( double[][] values, int[][] valueDepth )
{
// Matrix
// Horizontals
mRenderCanvas.drawLine( 5, 5 , 5+mWidth, 5 , ltgreyMatrixDashed ); // top
mRenderCanvas.drawLine( 5, 5+mHeight/4 , 5+mWidth, 5+mHeight/4 , ltgreyMatrixDashed ); // 2nd
mRenderCanvas.drawLine( 5, 5+mHeight/2 , 5+mWidth, 5+mHeight/2 , ltgreyMatrixDashed ); // middle
mRenderCanvas.drawLine( 5, 5+mHeight/4*3, 5+mWidth, 5+mHeight/4*3, ltgreyMatrixDashed ); // 3rd
// Verticals
mRenderCanvas.drawLine( 5+mWidth/4 , 5, 5+mWidth/4 , 5+mHeight, ltgreyMatrixDashed ); // 2nd
mRenderCanvas.drawLine( 5+mWidth/2 , 5, 5+mWidth/2 , 5+mHeight, ltgreyMatrixDashed ); // middle
mRenderCanvas.drawLine( 5+mWidth/4*3, 5, 5+mWidth/4*3, 5+mHeight, ltgreyMatrixDashed ); // 3rd
mRenderCanvas.drawLine( 5+mWidth-1 , 5, 5+mWidth-1 , 5+mHeight, ltgreyMatrixDashed ); // right
// The line
Path mPath;
int emptyValues = 0;
mPath = new Path();
for( int p=0;p<values.length;p++)
{
int start = 0;
while( valueDepth[p][start] == 0 && start < values[p].length-1 )
{
start++;
}
mPath.moveTo( (float)start+5, 5f+ (float) ( mHeight - ( ( values[p][start]-mMinAxis )*mHeight ) / ( mMaxAxis-mMinAxis ) ) );
for( int x=start;x<values[p].length;x++)
{
double y = mHeight - ( ( values[p][x]-mMinAxis )*mHeight ) / ( mMaxAxis-mMinAxis ) ;
if( valueDepth[p][x] > 0 )
{
if( emptyValues > mWidth/10 )
{
mPath.moveTo( (float)x+5, (float) y+5 );
}
else
{
mPath.lineTo( (float)x+5, (float) y+5 );
}
emptyValues = 0;
}
else
{
emptyValues++;
}
}
}
mRenderCanvas.drawPath( mPath, greenGraphLine );
// Axis's
mRenderCanvas.drawLine( 5, 5 , 5 , 5+mHeight, dkgreyMatrixLine );
mRenderCanvas.drawLine( 5, 5+mHeight, 5+mWidth, 5+mHeight, dkgreyMatrixLine );
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/utils/GraphCanvas.java | Java | gpl3 | 23,312 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.utils;
import android.content.Context;
import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
/**
* Work around based on input from the comment section of
* <a href="http://code.google.com/p/android/issues/detail?can=2&q=6191&colspec=ID%20Type%20Status%20Owner%20Summary%20Stars&id=6191">Issue 6191</a>
*
* @version $Id$
* @author rene (c) May 8, 2010, Sogeti B.V.
*/
public class ViewFlipper extends android.widget.ViewFlipper
{
private static final String TAG = "OGT.ViewFlipper";
public ViewFlipper(Context context)
{
super( context );
}
public ViewFlipper(Context context, AttributeSet attrs)
{
super( context, attrs );
}
/**
* On api level 7 unexpected exception occur during orientation switching.
* These are java.lang.IllegalArgumentException: Receiver not registered: android.widget.ViewFlipper$id
* exceptions. On level 7, 8 and 9 devices these are ignored.
*/
@Override
protected void onDetachedFromWindow()
{
if( Build.VERSION.SDK_INT > 7 )
{
try
{
super.onDetachedFromWindow();
}
catch( IllegalArgumentException e )
{
Log.w( TAG, "Android project issue 6191 workaround." );
/* Quick catch and continue on api level 7+, the Eclair 2.1 / 2.2 */
}
finally
{
super.stopFlipping();
}
}
else
{
super.onDetachedFromWindow();
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/utils/ViewFlipper.java | Java | gpl3 | 3,082 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Jul 9, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.tasks;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.util.Constants;
import org.apache.ogt.http.HttpEntity;
import org.apache.ogt.http.HttpException;
import org.apache.ogt.http.HttpResponse;
import org.apache.ogt.http.client.HttpClient;
import org.apache.ogt.http.client.methods.HttpPost;
import org.apache.ogt.http.entity.mime.MultipartEntity;
import org.apache.ogt.http.entity.mime.content.FileBody;
import org.apache.ogt.http.entity.mime.content.StringBody;
import org.apache.ogt.http.impl.client.DefaultHttpClient;
import org.apache.ogt.http.util.EntityUtils;
import android.content.Context;
import android.net.Uri;
import android.preference.PreferenceManager;
import android.util.Log;
import android.widget.Toast;
/**
* ????
*
* @version $Id:$
* @author rene (c) Jul 9, 2011, Sogeti B.V.
*/
public class JogmapSharing extends GpxCreator
{
private static final String TAG = "OGT.JogmapSharing";
private String jogmapResponseText;
public JogmapSharing(Context context, Uri trackUri, String chosenBaseFileName, boolean attachments, ProgressListener listener)
{
super(context, trackUri, chosenBaseFileName, attachments, listener);
}
@Override
protected Uri doInBackground(Void... params)
{
Uri result = super.doInBackground(params);
sendToJogmap(result);
return result;
}
@Override
protected void onPostExecute(Uri resultFilename)
{
super.onPostExecute(resultFilename);
CharSequence text = mContext.getString(R.string.osm_success) + jogmapResponseText;
Toast toast = Toast.makeText(mContext, text, Toast.LENGTH_LONG);
toast.show();
}
private void sendToJogmap(Uri fileUri)
{
String authCode = PreferenceManager.getDefaultSharedPreferences(mContext).getString(Constants.JOGRUNNER_AUTH, "");
File gpxFile = new File(fileUri.getEncodedPath());
HttpClient httpclient = new DefaultHttpClient();
URI jogmap = null;
int statusCode = 0;
HttpEntity responseEntity = null;
try
{
jogmap = new URI(mContext.getString(R.string.jogmap_post_url));
HttpPost method = new HttpPost(jogmap);
MultipartEntity entity = new MultipartEntity();
entity.addPart("id", new StringBody(authCode));
entity.addPart("mFile", new FileBody(gpxFile));
method.setEntity(entity);
HttpResponse response = httpclient.execute(method);
statusCode = response.getStatusLine().getStatusCode();
responseEntity = response.getEntity();
InputStream stream = responseEntity.getContent();
jogmapResponseText = XmlCreator.convertStreamToString(stream);
}
catch (IOException e)
{
String text = mContext.getString(R.string.jogmap_failed) + e.getLocalizedMessage();
handleError(mContext.getString(R.string.jogmap_task), e, text);
}
catch (URISyntaxException e)
{
String text = mContext.getString(R.string.jogmap_failed) + e.getLocalizedMessage();
handleError(mContext.getString(R.string.jogmap_task), e, text);
}
finally
{
if (responseEntity != null)
{
try
{
EntityUtils.consume(responseEntity);
}
catch (IOException e)
{
Log.e(TAG, "Failed to close the content stream", e);
}
}
}
if (statusCode != 200)
{
Log.e(TAG, "Wrong status code " + statusCode);
jogmapResponseText = mContext.getString(R.string.jogmap_failed) + jogmapResponseText;
handleError(mContext.getString(R.string.jogmap_task), new HttpException("Unexpected status reported by Jogmap"), jogmapResponseText);
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/tasks/JogmapSharing.java | Java | gpl3 | 5,565 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.tasks;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.nio.channels.FileChannel;
import java.util.Date;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.db.GPStracking.Media;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.util.Constants;
import org.xmlpull.v1.XmlSerializer;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Environment;
import android.util.Log;
import android.view.Window;
/**
* Async XML creation task Execute without parameters (Void) Update posted with
* single Integer And result is a filename in a String
*
* @version $Id$
* @author rene (c) May 29, 2011, Sogeti B.V.
*/
public abstract class XmlCreator extends AsyncTask<Void, Integer, Uri>
{
private String TAG = "OGT.XmlCreator";
private String mExportDirectoryPath;
private boolean mNeedsBundling;
String mChosenName;
private ProgressListener mProgressListener;
protected Context mContext;
protected Uri mTrackUri;
String mFileName;
private String mErrorText;
private Exception mException;
private String mTask;
public ProgressAdmin mProgressAdmin;
XmlCreator(Context context, Uri trackUri, String chosenFileName, ProgressListener listener)
{
mChosenName = chosenFileName;
mContext = context;
mTrackUri = trackUri;
mProgressListener = listener;
mProgressAdmin = new ProgressAdmin();
String trackName = extractCleanTrackName();
mFileName = cleanFilename(mChosenName, trackName);
}
public void executeOn(Executor executor)
{
if (Build.VERSION.SDK_INT >= 11)
{
executeOnExecutor(executor);
}
else
{
execute();
}
}
private String extractCleanTrackName()
{
Cursor trackCursor = null;
ContentResolver resolver = mContext.getContentResolver();
String trackName = "Untitled";
try
{
trackCursor = resolver.query(mTrackUri, new String[] { Tracks.NAME }, null, null, null);
if (trackCursor.moveToLast())
{
trackName = cleanFilename(trackCursor.getString(0), trackName);
}
}
finally
{
if (trackCursor != null)
{
trackCursor.close();
}
}
return trackName;
}
/**
* Calculated the total progress sum expected from a export to file This is
* the sum of the number of waypoints and media entries times 100. The whole
* number is doubled when compression is needed.
*/
public void determineProgressGoal()
{
if (mProgressListener != null)
{
Uri allWaypointsUri = Uri.withAppendedPath(mTrackUri, "waypoints");
Uri allMediaUri = Uri.withAppendedPath(mTrackUri, "media");
Cursor cursor = null;
ContentResolver resolver = mContext.getContentResolver();
try
{
cursor = resolver.query(allWaypointsUri, new String[] { "count(" + Waypoints.TABLE + "." + Waypoints._ID + ")" }, null, null, null);
if (cursor.moveToLast())
{
mProgressAdmin.setWaypointCount(cursor.getInt(0));
}
cursor.close();
cursor = resolver.query(allMediaUri, new String[] { "count(" + Media.TABLE + "." + Media._ID + ")" }, null, null, null);
if (cursor.moveToLast())
{
mProgressAdmin.setMediaCount(cursor.getInt(0));
}
cursor.close();
cursor = resolver.query(allMediaUri, new String[] { "count(" + Tracks._ID + ")" }, Media.URI + " LIKE ? and " + Media.URI + " NOT LIKE ?",
new String[] { "file://%", "%txt" }, null);
if (cursor.moveToLast())
{
mProgressAdmin.setCompress( cursor.getInt(0) > 0 );
}
}
finally
{
if (cursor != null)
{
cursor.close();
}
}
}
else
{
Log.w(TAG, "Exporting " + mTrackUri + " without progress!");
}
}
/**
* Removes all non-word chars (\W) from the text
*
* @param fileName
* @param defaultName
* @return a string larger then 0 with either word chars remaining from the
* input or the default provided
*/
public static String cleanFilename(String fileName, String defaultName)
{
if (fileName == null || "".equals(fileName))
{
fileName = defaultName;
}
else
{
fileName = fileName.replaceAll("\\W", "");
fileName = (fileName.length() > 0) ? fileName : defaultName;
}
return fileName;
}
/**
* Includes media into the export directory and returns the relative path of
* the media
*
* @param inputFilePath
* @return file path relative to the export dir
* @throws IOException
*/
protected String includeMediaFile(String inputFilePath) throws IOException
{
mNeedsBundling = true;
File source = new File(inputFilePath);
File target = new File(mExportDirectoryPath + "/" + source.getName());
// Log.d( TAG, String.format( "Copy %s to %s", source, target ) );
if (source.exists())
{
FileInputStream fileInputStream = new FileInputStream(source);
FileChannel inChannel = fileInputStream.getChannel();
FileOutputStream fileOutputStream = new FileOutputStream(target);
FileChannel outChannel = fileOutputStream.getChannel();
try
{
inChannel.transferTo(0, inChannel.size(), outChannel);
}
finally
{
if (inChannel != null) inChannel.close();
if (outChannel != null) outChannel.close();
if (fileInputStream != null) fileInputStream.close();
if (fileOutputStream != null) fileOutputStream.close();
}
}
else
{
Log.w( TAG, "Failed to add file to new XML export. Missing: "+inputFilePath );
}
mProgressAdmin.addMediaProgress();
return target.getName();
}
/**
* Just to start failing early
*
* @throws IOException
*/
protected void verifySdCardAvailibility() throws IOException
{
String state = Environment.getExternalStorageState();
if (!Environment.MEDIA_MOUNTED.equals(state))
{
throw new IOException("The ExternalStorage is not mounted, unable to export files for sharing.");
}
}
/**
* Create a zip of the export directory based on the given filename
*
* @param fileName The directory to be replaced by a zipped file of the same
* name
* @param extension
* @return full path of the build zip file
* @throws IOException
*/
protected String bundlingMediaAndXml(String fileName, String extension) throws IOException
{
String zipFilePath;
if (fileName.endsWith(".zip") || fileName.endsWith(extension))
{
zipFilePath = Constants.getSdCardDirectory(mContext) + fileName;
}
else
{
zipFilePath = Constants.getSdCardDirectory(mContext) + fileName + extension;
}
String[] filenames = new File(mExportDirectoryPath).list();
byte[] buf = new byte[1024];
ZipOutputStream zos = null;
try
{
zos = new ZipOutputStream(new FileOutputStream(zipFilePath));
for (int i = 0; i < filenames.length; i++)
{
String entryFilePath = mExportDirectoryPath + "/" + filenames[i];
FileInputStream in = new FileInputStream(entryFilePath);
zos.putNextEntry(new ZipEntry(filenames[i]));
int len;
while ((len = in.read(buf)) >= 0)
{
zos.write(buf, 0, len);
}
zos.closeEntry();
in.close();
mProgressAdmin.addCompressProgress();
}
}
finally
{
if (zos != null)
{
zos.close();
}
}
deleteRecursive(new File(mExportDirectoryPath));
return zipFilePath;
}
public static boolean deleteRecursive(File file)
{
if (file.isDirectory())
{
String[] children = file.list();
for (int i = 0; i < children.length; i++)
{
boolean success = deleteRecursive(new File(file, children[i]));
if (!success)
{
return false;
}
}
}
return file.delete();
}
public void setExportDirectoryPath(String exportDirectoryPath)
{
this.mExportDirectoryPath = exportDirectoryPath;
}
public String getExportDirectoryPath()
{
return mExportDirectoryPath;
}
public void quickTag(XmlSerializer serializer, String ns, String tag, String content) throws IllegalArgumentException, IllegalStateException, IOException
{
if( tag == null)
{
tag = "";
}
if( content == null)
{
content = "";
}
serializer.text("\n");
serializer.startTag(ns, tag);
serializer.text(content);
serializer.endTag(ns, tag);
}
public boolean needsBundling()
{
return mNeedsBundling;
}
public static String convertStreamToString(InputStream is) throws IOException
{
String result = "";
/*
* To convert the InputStream to String we use the Reader.read(char[]
* buffer) method. We iterate until the Reader return -1 which means
* there's no more data to read. We use the StringWriter class to produce
* the string.
*/
if (is != null)
{
Writer writer = new StringWriter();
char[] buffer = new char[8192];
try
{
Reader reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
int n;
while ((n = reader.read(buffer)) != -1)
{
writer.write(buffer, 0, n);
}
}
finally
{
is.close();
}
result = writer.toString();
}
return result;
}
public static InputStream convertStreamToLoggedStream(String tag, InputStream is) throws IOException
{
String result = "";
/*
* To convert the InputStream to String we use the Reader.read(char[]
* buffer) method. We iterate until the Reader return -1 which means
* there's no more data to read. We use the StringWriter class to produce
* the string.
*/
if (is != null)
{
Writer writer = new StringWriter();
char[] buffer = new char[8192];
try
{
Reader reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
int n;
while ((n = reader.read(buffer)) != -1)
{
writer.write(buffer, 0, n);
}
}
finally
{
is.close();
}
result = writer.toString();
}
InputStream in = new ByteArrayInputStream(result.getBytes("UTF-8"));
return in;
}
protected abstract String getContentType();
protected void handleError(String task, Exception e, String text)
{
Log.e(TAG, "Unable to save ", e);
mTask = task;
mException = e;
mErrorText = text;
cancel(false);
throw new CancellationException(text);
}
@Override
protected void onPreExecute()
{
if(mProgressListener!= null)
{
mProgressListener.started();
}
}
@Override
protected void onProgressUpdate(Integer... progress)
{
if(mProgressListener!= null)
{
mProgressListener.setProgress(mProgressAdmin.getProgress());
}
}
@Override
protected void onPostExecute(Uri resultFilename)
{
if(mProgressListener!= null)
{
mProgressListener.finished(resultFilename);
}
}
@Override
protected void onCancelled()
{
if(mProgressListener!= null)
{
mProgressListener.finished(null);
mProgressListener.showError(mTask, mErrorText, mException);
}
}
public class ProgressAdmin
{
long lastUpdate;
private boolean compressCount;
private boolean compressProgress;
private boolean uploadCount;
private boolean uploadProgress;
private int mediaCount;
private int mediaProgress;
private int waypointCount;
private int waypointProgress;
private long photoUploadCount ;
private long photoUploadProgress ;
public void addMediaProgress()
{
mediaProgress ++;
}
public void addCompressProgress()
{
compressProgress = true;
}
public void addUploadProgress()
{
uploadProgress = true;
}
public void addPhotoUploadProgress(long length)
{
photoUploadProgress += length;
}
/**
* Get the progress on scale 0 ... Window.PROGRESS_END
*
* @return Returns the progress as a int.
*/
public int getProgress()
{
int blocks = 0;
if( waypointCount > 0 ){ blocks++; }
if( mediaCount > 0 ){ blocks++; }
if( compressCount ){ blocks++; }
if( uploadCount ){ blocks++; }
if( photoUploadCount > 0 ){ blocks++; }
int progress;
if( blocks > 0 )
{
int blockSize = Window.PROGRESS_END / blocks;
progress = waypointCount > 0 ? blockSize * waypointProgress / waypointCount : 0;
progress += mediaCount > 0 ? blockSize * mediaProgress / mediaCount : 0;
progress += compressProgress ? blockSize : 0;
progress += uploadProgress ? blockSize : 0;
progress += photoUploadCount > 0 ? blockSize * photoUploadProgress / photoUploadCount : 0;
}
else
{
progress = 0;
}
//Log.d( TAG, "Progress updated to "+progress);
return progress;
}
public void setWaypointCount(int waypoint)
{
waypointCount = waypoint;
considerPublishProgress();
}
public void setMediaCount(int media)
{
mediaCount = media;
considerPublishProgress();
}
public void setCompress( boolean compress)
{
compressCount = compress;
considerPublishProgress();
}
public void setUpload( boolean upload)
{
uploadCount = upload;
considerPublishProgress();
}
public void setPhotoUpload(long length)
{
photoUploadCount += length;
considerPublishProgress();
}
public void addWaypointProgress(int i)
{
waypointProgress += i;
considerPublishProgress();
}
public void considerPublishProgress()
{
long now = new Date().getTime();
if( now - lastUpdate > 1000 )
{
lastUpdate = now;
publishProgress();
}
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/tasks/XmlCreator.java | Java | gpl3 | 17,459 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.tasks;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.db.GPStracking;
import nl.sogeti.android.gpstracker.db.GPStracking.Media;
import nl.sogeti.android.gpstracker.db.GPStracking.Segments;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.util.Constants;
import org.xmlpull.v1.XmlSerializer;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.MediaStore.MediaColumns;
import android.util.Log;
import android.util.Xml;
/**
* Create a GPX version of a stored track
*
* @version $Id$
* @author rene (c) Mar 22, 2009, Sogeti B.V.
*/
public class GpxCreator extends XmlCreator
{
public static final String NS_SCHEMA = "http://www.w3.org/2001/XMLSchema-instance";
public static final String NS_GPX_11 = "http://www.topografix.com/GPX/1/1";
public static final String NS_GPX_10 = "http://www.topografix.com/GPX/1/0";
public static final String NS_OGT_10 = "http://gpstracker.android.sogeti.nl/GPX/1/0";
public static final SimpleDateFormat ZULU_DATE_FORMATER = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
static
{
TimeZone utc = TimeZone.getTimeZone("UTC");
ZULU_DATE_FORMATER.setTimeZone(utc); // ZULU_DATE_FORMAT format ends with Z for UTC so make that true
}
private String TAG = "OGT.GpxCreator";
private boolean includeAttachments;
protected String mName;
public GpxCreator(Context context, Uri trackUri, String chosenBaseFileName, boolean attachments, ProgressListener listener)
{
super(context, trackUri, chosenBaseFileName, listener);
includeAttachments = attachments;
}
@Override
protected Uri doInBackground(Void... params)
{
determineProgressGoal();
Uri resultFilename = exportGpx();
return resultFilename;
}
protected Uri exportGpx()
{
String xmlFilePath;
if (mFileName.endsWith(".gpx") || mFileName.endsWith(".xml"))
{
setExportDirectoryPath(Constants.getSdCardDirectory(mContext) + mFileName.substring(0, mFileName.length() - 4));
xmlFilePath = getExportDirectoryPath() + "/" + mFileName;
}
else
{
setExportDirectoryPath(Constants.getSdCardDirectory(mContext) + mFileName);
xmlFilePath = getExportDirectoryPath() + "/" + mFileName + ".gpx";
}
new File(getExportDirectoryPath()).mkdirs();
String resultFilename = null;
FileOutputStream fos = null;
BufferedOutputStream buf = null;
try
{
verifySdCardAvailibility();
XmlSerializer serializer = Xml.newSerializer();
File xmlFile = new File(xmlFilePath);
fos = new FileOutputStream(xmlFile);
buf = new BufferedOutputStream(fos, 8 * 8192);
serializer.setOutput(buf, "UTF-8");
serializeTrack(mTrackUri, serializer);
buf.close();
buf = null;
fos.close();
fos = null;
if (needsBundling())
{
resultFilename = bundlingMediaAndXml(xmlFile.getParentFile().getName(), ".zip");
}
else
{
File finalFile = new File(Constants.getSdCardDirectory(mContext) + xmlFile.getName());
xmlFile.renameTo(finalFile);
resultFilename = finalFile.getAbsolutePath();
XmlCreator.deleteRecursive(xmlFile.getParentFile());
}
mFileName = new File(resultFilename).getName();
}
catch (FileNotFoundException e)
{
String text = mContext.getString(R.string.ticker_failed) + " \"" + xmlFilePath + "\" " + mContext.getString(R.string.error_filenotfound);
handleError(mContext.getString(R.string.taskerror_gpx_write), e, text);
}
catch (IllegalArgumentException e)
{
String text = mContext.getString(R.string.ticker_failed) + " \"" + xmlFilePath + "\" " + mContext.getString(R.string.error_filename);
handleError(mContext.getString(R.string.taskerror_gpx_write), e, text);
}
catch (IllegalStateException e)
{
String text = mContext.getString(R.string.ticker_failed) + " \"" + xmlFilePath + "\" " + mContext.getString(R.string.error_buildxml);
handleError(mContext.getString(R.string.taskerror_gpx_write), e, text);
}
catch (IOException e)
{
String text = mContext.getString(R.string.ticker_failed) + " \"" + xmlFilePath + "\" " + mContext.getString(R.string.error_writesdcard);
handleError(mContext.getString(R.string.taskerror_gpx_write), e, text);
}
finally
{
if (buf != null)
{
try
{
buf.close();
}
catch (IOException e)
{
Log.e(TAG, "Failed to close buf after completion, ignoring.", e);
}
}
if (fos != null)
{
try
{
fos.close();
}
catch (IOException e)
{
Log.e(TAG, "Failed to close fos after completion, ignoring.", e);
}
}
}
return Uri.fromFile(new File(resultFilename));
}
private void serializeTrack(Uri trackUri, XmlSerializer serializer) throws IllegalArgumentException, IllegalStateException, IOException
{
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
serializer.startDocument("UTF-8", true);
serializer.setPrefix("xsi", NS_SCHEMA);
serializer.setPrefix("gpx10", NS_GPX_10);
serializer.setPrefix("ogt10", NS_OGT_10);
serializer.text("\n");
serializer.startTag("", "gpx");
serializer.attribute(null, "version", "1.1");
serializer.attribute(null, "creator", "nl.sogeti.android.gpstracker");
serializer.attribute(NS_SCHEMA, "schemaLocation", NS_GPX_11 + " http://www.topografix.com/gpx/1/1/gpx.xsd");
serializer.attribute(null, "xmlns", NS_GPX_11);
// <metadata/> Big header of the track
serializeTrackHeader(mContext, serializer, trackUri);
// <wpt/> [0...] Waypoints
if (includeAttachments)
{
serializeWaypoints(mContext, serializer, Uri.withAppendedPath(trackUri, "/media"));
}
// <trk/> [0...] Track
serializer.text("\n");
serializer.startTag("", "trk");
serializer.text("\n");
serializer.startTag("", "name");
serializer.text(mName);
serializer.endTag("", "name");
// The list of segments in the track
serializeSegments(serializer, Uri.withAppendedPath(trackUri, "segments"));
serializer.text("\n");
serializer.endTag("", "trk");
serializer.text("\n");
serializer.endTag("", "gpx");
serializer.endDocument();
}
private void serializeTrackHeader(Context context, XmlSerializer serializer, Uri trackUri) throws IOException
{
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
ContentResolver resolver = context.getContentResolver();
Cursor trackCursor = null;
String databaseName = null;
try
{
trackCursor = resolver.query(trackUri, new String[] { Tracks._ID, Tracks.NAME, Tracks.CREATION_TIME }, null, null, null);
if (trackCursor.moveToFirst())
{
databaseName = trackCursor.getString(1);
serializer.text("\n");
serializer.startTag("", "metadata");
serializer.text("\n");
serializer.startTag("", "time");
Date time = new Date(trackCursor.getLong(2));
synchronized (ZULU_DATE_FORMATER)
{
serializer.text(ZULU_DATE_FORMATER.format(time));
}
serializer.endTag("", "time");
serializer.text("\n");
serializer.endTag("", "metadata");
}
}
finally
{
if (trackCursor != null)
{
trackCursor.close();
}
}
if (mName == null)
{
mName = "Untitled";
}
if (databaseName != null && !databaseName.equals(""))
{
mName = databaseName;
}
if (mChosenName != null && !mChosenName.equals(""))
{
mName = mChosenName;
}
}
private void serializeSegments(XmlSerializer serializer, Uri segments) throws IOException
{
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
Cursor segmentCursor = null;
ContentResolver resolver = mContext.getContentResolver();
try
{
segmentCursor = resolver.query(segments, new String[] { Segments._ID }, null, null, null);
if (segmentCursor.moveToFirst())
{
do
{
Uri waypoints = Uri.withAppendedPath(segments, segmentCursor.getLong(0) + "/waypoints");
serializer.text("\n");
serializer.startTag("", "trkseg");
serializeTrackPoints(serializer, waypoints);
serializer.text("\n");
serializer.endTag("", "trkseg");
}
while (segmentCursor.moveToNext());
}
}
finally
{
if (segmentCursor != null)
{
segmentCursor.close();
}
}
}
private void serializeTrackPoints(XmlSerializer serializer, Uri waypoints) throws IOException
{
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
Cursor waypointsCursor = null;
ContentResolver resolver = mContext.getContentResolver();
try
{
waypointsCursor = resolver.query(waypoints, new String[] { Waypoints.LONGITUDE, Waypoints.LATITUDE, Waypoints.TIME, Waypoints.ALTITUDE, Waypoints._ID, Waypoints.SPEED, Waypoints.ACCURACY,
Waypoints.BEARING }, null, null, null);
if (waypointsCursor.moveToFirst())
{
do
{
mProgressAdmin.addWaypointProgress(1);
serializer.text("\n");
serializer.startTag("", "trkpt");
serializer.attribute(null, "lat", Double.toString(waypointsCursor.getDouble(1)));
serializer.attribute(null, "lon", Double.toString(waypointsCursor.getDouble(0)));
serializer.text("\n");
serializer.startTag("", "ele");
serializer.text(Double.toString(waypointsCursor.getDouble(3)));
serializer.endTag("", "ele");
serializer.text("\n");
serializer.startTag("", "time");
Date time = new Date(waypointsCursor.getLong(2));
synchronized (ZULU_DATE_FORMATER)
{
serializer.text(ZULU_DATE_FORMATER.format(time));
}
serializer.endTag("", "time");
serializer.text("\n");
serializer.startTag("", "extensions");
double speed = waypointsCursor.getDouble(5);
double accuracy = waypointsCursor.getDouble(6);
double bearing = waypointsCursor.getDouble(7);
if (speed > 0.0)
{
quickTag(serializer, NS_GPX_10, "speed", Double.toString(speed));
}
if (accuracy > 0.0)
{
quickTag(serializer, NS_OGT_10, "accuracy", Double.toString(accuracy));
}
if (bearing != 0.0)
{
quickTag(serializer, NS_GPX_10, "course", Double.toString(bearing));
}
serializer.endTag("", "extensions");
serializer.text("\n");
serializer.endTag("", "trkpt");
}
while (waypointsCursor.moveToNext());
}
}
finally
{
if (waypointsCursor != null)
{
waypointsCursor.close();
}
}
}
private void serializeWaypoints(Context context, XmlSerializer serializer, Uri media) throws IOException
{
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
Cursor mediaCursor = null;
Cursor waypointCursor = null;
BufferedReader buf = null;
ContentResolver resolver = context.getContentResolver();
try
{
mediaCursor = resolver.query(media, new String[] { Media.URI, Media.TRACK, Media.SEGMENT, Media.WAYPOINT }, null, null, null);
if (mediaCursor.moveToFirst())
{
do
{
Uri waypointUri = Waypoints.buildUri(mediaCursor.getLong(1), mediaCursor.getLong(2), mediaCursor.getLong(3));
waypointCursor = resolver.query(waypointUri, new String[] { Waypoints.LATITUDE, Waypoints.LONGITUDE, Waypoints.ALTITUDE, Waypoints.TIME }, null, null, null);
serializer.text("\n");
serializer.startTag("", "wpt");
if (waypointCursor != null && waypointCursor.moveToFirst())
{
serializer.attribute(null, "lat", Double.toString(waypointCursor.getDouble(0)));
serializer.attribute(null, "lon", Double.toString(waypointCursor.getDouble(1)));
serializer.text("\n");
serializer.startTag("", "ele");
serializer.text(Double.toString(waypointCursor.getDouble(2)));
serializer.endTag("", "ele");
serializer.text("\n");
serializer.startTag("", "time");
Date time = new Date(waypointCursor.getLong(3));
synchronized (ZULU_DATE_FORMATER)
{
serializer.text(ZULU_DATE_FORMATER.format(time));
}
serializer.endTag("", "time");
}
if (waypointCursor != null)
{
waypointCursor.close();
waypointCursor = null;
}
Uri mediaUri = Uri.parse(mediaCursor.getString(0));
if (mediaUri.getScheme().equals("file"))
{
if (mediaUri.getLastPathSegment().endsWith("3gp"))
{
String fileName = includeMediaFile(mediaUri.getLastPathSegment());
quickTag(serializer, "", "name", fileName);
serializer.startTag("", "link");
serializer.attribute(null, "href", fileName);
quickTag(serializer, "", "text", fileName);
serializer.endTag("", "link");
}
else if (mediaUri.getLastPathSegment().endsWith("jpg"))
{
String mediaPathPrefix = Constants.getSdCardDirectory(mContext);
String fileName = includeMediaFile(mediaPathPrefix + mediaUri.getLastPathSegment());
quickTag(serializer, "", "name", fileName);
serializer.startTag("", "link");
serializer.attribute(null, "href", fileName);
quickTag(serializer, "", "text", fileName);
serializer.endTag("", "link");
}
else if (mediaUri.getLastPathSegment().endsWith("txt"))
{
quickTag(serializer, "", "name", mediaUri.getLastPathSegment());
serializer.startTag("", "desc");
if (buf != null)
{
buf.close();
}
buf = new BufferedReader(new FileReader(mediaUri.getEncodedPath()));
String line;
while ((line = buf.readLine()) != null)
{
serializer.text(line);
serializer.text("\n");
}
serializer.endTag("", "desc");
}
}
else if (mediaUri.getScheme().equals("content"))
{
if ((GPStracking.AUTHORITY + ".string").equals(mediaUri.getAuthority()))
{
quickTag(serializer, "", "name", mediaUri.getLastPathSegment());
}
else if (mediaUri.getAuthority().equals("media"))
{
Cursor mediaItemCursor = null;
try
{
mediaItemCursor = resolver.query(mediaUri, new String[] { MediaColumns.DATA, MediaColumns.DISPLAY_NAME }, null, null, null);
if (mediaItemCursor.moveToFirst())
{
String fileName = includeMediaFile(mediaItemCursor.getString(0));
quickTag(serializer, "", "name", fileName);
serializer.startTag("", "link");
serializer.attribute(null, "href", fileName);
quickTag(serializer, "", "text", mediaItemCursor.getString(1));
serializer.endTag("", "link");
}
}
finally
{
if (mediaItemCursor != null)
{
mediaItemCursor.close();
}
}
}
}
serializer.text("\n");
serializer.endTag("", "wpt");
}
while (mediaCursor.moveToNext());
}
}
finally
{
if (mediaCursor != null)
{
mediaCursor.close();
}
if (waypointCursor != null)
{
waypointCursor.close();
}
if (buf != null)
buf.close();
}
}
@Override
protected String getContentType()
{
return needsBundling() ? "application/zip" : "text/xml";
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/tasks/GpxCreator.java | Java | gpl3 | 20,276 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.tasks;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import java.util.Vector;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.util.ProgressFilterInputStream;
import nl.sogeti.android.gpstracker.util.UnicodeReader;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.util.Log;
import android.view.Window;
public class GpxParser extends AsyncTask<Uri, Void, Uri>
{
private static final String LATITUDE_ATRIBUTE = "lat";
private static final String LONGITUDE_ATTRIBUTE = "lon";
private static final String TRACK_ELEMENT = "trkpt";
private static final String SEGMENT_ELEMENT = "trkseg";
private static final String NAME_ELEMENT = "name";
private static final String TIME_ELEMENT = "time";
private static final String ELEVATION_ELEMENT = "ele";
private static final String COURSE_ELEMENT = "course";
private static final String ACCURACY_ELEMENT = "accuracy";
private static final String SPEED_ELEMENT = "speed";
public static final SimpleDateFormat ZULU_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
public static final SimpleDateFormat ZULU_DATE_FORMAT_MS = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
public static final SimpleDateFormat ZULU_DATE_FORMAT_BC = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss 'UTC'");
protected static final int DEFAULT_UNKNOWN_FILESIZE = 1024 * 1024 * 10;
private static final String TAG = "OGT.GpxParser";
static
{
TimeZone utc = TimeZone.getTimeZone("UTC");
ZULU_DATE_FORMAT.setTimeZone(utc); // ZULU_DATE_FORMAT format ends with Z for UTC so make that true
ZULU_DATE_FORMAT_MS.setTimeZone(utc);
}
private ContentResolver mContentResolver;
protected String mErrorDialogMessage;
protected Exception mErrorDialogException;
protected Context mContext;
private ProgressListener mProgressListener;
protected ProgressAdmin mProgressAdmin;
public GpxParser(Context context, ProgressListener progressListener)
{
mContext = context;
mProgressListener = progressListener;
mContentResolver = mContext.getContentResolver();
}
public void executeOn(Executor executor)
{
if (Build.VERSION.SDK_INT >= 11)
{
executeOnExecutor(executor);
}
else
{
execute();
}
}
public void determineProgressGoal(Uri importFileUri)
{
mProgressAdmin = new ProgressAdmin();
mProgressAdmin.setContentLength(DEFAULT_UNKNOWN_FILESIZE);
if (importFileUri != null && importFileUri.getScheme().equals("file"))
{
File file = new File(importFileUri.getPath());
mProgressAdmin.setContentLength(file.length());
}
}
public Uri importUri(Uri importFileUri)
{
Uri result = null;
String trackName = null;
InputStream fis = null;
if (importFileUri.getScheme().equals("file"))
{
trackName = importFileUri.getLastPathSegment();
}
try
{
fis = mContentResolver.openInputStream(importFileUri);
}
catch (IOException e)
{
handleError(e, mContext.getString(R.string.error_importgpx_io));
}
result = importTrack( fis, trackName);
return result;
}
/**
* Read a stream containing GPX XML into the OGT content provider
*
* @param fis opened stream the read from, will be closed after this call
* @param trackName
* @return
*/
public Uri importTrack( InputStream fis, String trackName )
{
Uri trackUri = null;
int eventType;
ContentValues lastPosition = null;
Vector<ContentValues> bulk = new Vector<ContentValues>();
boolean speed = false;
boolean accuracy = false;
boolean bearing = false;
boolean elevation = false;
boolean name = false;
boolean time = false;
Long importDate = Long.valueOf(new Date().getTime());
try
{
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
factory.setNamespaceAware(true);
XmlPullParser xmlParser = factory.newPullParser();
ProgressFilterInputStream pfis = new ProgressFilterInputStream(fis, mProgressAdmin);
BufferedInputStream bis = new BufferedInputStream(pfis);
UnicodeReader ur = new UnicodeReader(bis, "UTF-8");
xmlParser.setInput(ur);
eventType = xmlParser.getEventType();
String attributeName;
Uri segmentUri = null;
while (eventType != XmlPullParser.END_DOCUMENT)
{
if (eventType == XmlPullParser.START_TAG)
{
if (xmlParser.getName().equals(NAME_ELEMENT))
{
name = true;
}
else
{
ContentValues trackContent = new ContentValues();
trackContent.put(Tracks.NAME, trackName);
if (xmlParser.getName().equals("trk") && trackUri == null)
{
trackUri = startTrack(trackContent);
}
else if (xmlParser.getName().equals(SEGMENT_ELEMENT))
{
segmentUri = startSegment(trackUri);
}
else if (xmlParser.getName().equals(TRACK_ELEMENT))
{
lastPosition = new ContentValues();
for (int i = 0; i < 2; i++)
{
attributeName = xmlParser.getAttributeName(i);
if (attributeName.equals(LATITUDE_ATRIBUTE))
{
lastPosition.put(Waypoints.LATITUDE, Double.valueOf(xmlParser.getAttributeValue(i)));
}
else if (attributeName.equals(LONGITUDE_ATTRIBUTE))
{
lastPosition.put(Waypoints.LONGITUDE, Double.valueOf(xmlParser.getAttributeValue(i)));
}
}
}
else if (xmlParser.getName().equals(SPEED_ELEMENT))
{
speed = true;
}
else if (xmlParser.getName().equals(ACCURACY_ELEMENT))
{
accuracy = true;
}
else if (xmlParser.getName().equals(COURSE_ELEMENT))
{
bearing = true;
}
else if (xmlParser.getName().equals(ELEVATION_ELEMENT))
{
elevation = true;
}
else if (xmlParser.getName().equals(TIME_ELEMENT))
{
time = true;
}
}
}
else if (eventType == XmlPullParser.END_TAG)
{
if (xmlParser.getName().equals(NAME_ELEMENT))
{
name = false;
}
else if (xmlParser.getName().equals(SPEED_ELEMENT))
{
speed = false;
}
else if (xmlParser.getName().equals(ACCURACY_ELEMENT))
{
accuracy = false;
}
else if (xmlParser.getName().equals(COURSE_ELEMENT))
{
bearing = false;
}
else if (xmlParser.getName().equals(ELEVATION_ELEMENT))
{
elevation = false;
}
else if (xmlParser.getName().equals(TIME_ELEMENT))
{
time = false;
}
else if (xmlParser.getName().equals(SEGMENT_ELEMENT))
{
if (segmentUri == null)
{
segmentUri = startSegment( trackUri );
}
mContentResolver.bulkInsert(Uri.withAppendedPath(segmentUri, "waypoints"), bulk.toArray(new ContentValues[bulk.size()]));
bulk.clear();
}
else if (xmlParser.getName().equals(TRACK_ELEMENT))
{
if (!lastPosition.containsKey(Waypoints.TIME))
{
lastPosition.put(Waypoints.TIME, importDate);
}
if (!lastPosition.containsKey(Waypoints.SPEED))
{
lastPosition.put(Waypoints.SPEED, 0);
}
bulk.add(lastPosition);
lastPosition = null;
}
}
else if (eventType == XmlPullParser.TEXT)
{
String text = xmlParser.getText();
if (name)
{
ContentValues nameValues = new ContentValues();
nameValues.put(Tracks.NAME, text);
if (trackUri == null)
{
trackUri = startTrack(new ContentValues());
}
mContentResolver.update(trackUri, nameValues, null, null);
}
else if (lastPosition != null && speed)
{
lastPosition.put(Waypoints.SPEED, Double.parseDouble(text));
}
else if (lastPosition != null && accuracy)
{
lastPosition.put(Waypoints.ACCURACY, Double.parseDouble(text));
}
else if (lastPosition != null && bearing)
{
lastPosition.put(Waypoints.BEARING, Double.parseDouble(text));
}
else if (lastPosition != null && elevation)
{
lastPosition.put(Waypoints.ALTITUDE, Double.parseDouble(text));
}
else if (lastPosition != null && time)
{
lastPosition.put(Waypoints.TIME, parseXmlDateTime(text));
}
}
eventType = xmlParser.next();
}
}
catch (XmlPullParserException e)
{
handleError(e, mContext.getString(R.string.error_importgpx_xml));
}
catch (IOException e)
{
handleError(e, mContext.getString(R.string.error_importgpx_io));
}
finally
{
try
{
fis.close();
}
catch (IOException e)
{
Log.w( TAG, "Failed closing inputstream");
}
}
return trackUri;
}
private Uri startSegment(Uri trackUri)
{
if (trackUri == null)
{
trackUri = startTrack(new ContentValues());
}
return mContentResolver.insert(Uri.withAppendedPath(trackUri, "segments"), new ContentValues());
}
private Uri startTrack(ContentValues trackContent)
{
return mContentResolver.insert(Tracks.CONTENT_URI, trackContent);
}
public static Long parseXmlDateTime(String text)
{
Long dateTime = 0L;
try
{
if(text==null)
{
throw new ParseException("Unable to parse dateTime "+text+" of length ", 0);
}
int length = text.length();
switch (length)
{
case 20:
synchronized (ZULU_DATE_FORMAT)
{
dateTime = Long.valueOf(ZULU_DATE_FORMAT.parse(text).getTime());
}
break;
case 23:
synchronized (ZULU_DATE_FORMAT_BC)
{
dateTime = Long.valueOf(ZULU_DATE_FORMAT_BC.parse(text).getTime());
}
break;
case 24:
synchronized (ZULU_DATE_FORMAT_MS)
{
dateTime = Long.valueOf(ZULU_DATE_FORMAT_MS.parse(text).getTime());
}
break;
default:
throw new ParseException("Unable to parse dateTime "+text+" of length "+length, 0);
}
}
catch (ParseException e) {
Log.w(TAG, "Failed to parse a time-date", e);
}
return dateTime;
}
/**
*
* @param e
* @param text
*/
protected void handleError(Exception dialogException, String dialogErrorMessage)
{
Log.e(TAG, "Unable to save ", dialogException);
mErrorDialogException = dialogException;
mErrorDialogMessage = dialogErrorMessage;
cancel(false);
throw new CancellationException(dialogErrorMessage);
}
@Override
protected void onPreExecute()
{
mProgressListener.started();
}
@Override
protected Uri doInBackground(Uri... params)
{
Uri importUri = params[0];
determineProgressGoal( importUri);
Uri result = importUri( importUri );
return result;
}
@Override
protected void onProgressUpdate(Void... values)
{
mProgressListener.setProgress(mProgressAdmin.getProgress());
}
@Override
protected void onPostExecute(Uri result)
{
mProgressListener.finished(result);
}
@Override
protected void onCancelled()
{
mProgressListener.showError(mContext.getString(R.string.taskerror_gpx_import), mErrorDialogMessage, mErrorDialogException);
}
public class ProgressAdmin
{
private long progressedBytes;
private long contentLength;
private int progress;
private long lastUpdate;
/**
* Get the progress.
*
* @return Returns the progress as a int.
*/
public int getProgress()
{
return progress;
}
public void addBytesProgress(int addedBytes)
{
progressedBytes += addedBytes;
progress = (int) (Window.PROGRESS_END * progressedBytes / contentLength);
considerPublishProgress();
}
public void setContentLength(long contentLength)
{
this.contentLength = contentLength;
}
public void considerPublishProgress()
{
long now = new Date().getTime();
if( now - lastUpdate > 1000 )
{
lastUpdate = now;
publishProgress();
}
}
}
}; | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/tasks/GpxParser.java | Java | gpl3 | 16,565 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Jul 9, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.tasks;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.ShareTrack;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import android.content.Context;
import android.net.Uri;
/**
* ????
*
* @version $Id:$
* @author rene (c) Jul 9, 2011, Sogeti B.V.
*/
public class KmzSharing extends KmzCreator
{
public KmzSharing(Context context, Uri trackUri, String chosenFileName, ProgressListener listener)
{
super(context, trackUri, chosenFileName, listener);
}
@Override
protected void onPostExecute(Uri resultFilename)
{
super.onPostExecute(resultFilename);
ShareTrack.sendFile(mContext, resultFilename, mContext.getString(R.string.email_kmzbody), getContentType());
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/tasks/KmzSharing.java | Java | gpl3 | 2,322 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.tasks;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.db.GPStracking;
import nl.sogeti.android.gpstracker.db.GPStracking.Media;
import nl.sogeti.android.gpstracker.db.GPStracking.Segments;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.util.Constants;
import org.xmlpull.v1.XmlSerializer;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.MediaStore.MediaColumns;
import android.util.Log;
import android.util.Xml;
/**
* Create a KMZ version of a stored track
*
* @version $Id$
* @author rene (c) Mar 22, 2009, Sogeti B.V.
*/
public class KmzCreator extends XmlCreator
{
public static final String NS_SCHEMA = "http://www.w3.org/2001/XMLSchema-instance";
public static final String NS_KML_22 = "http://www.opengis.net/kml/2.2";
public static final SimpleDateFormat ZULU_DATE_FORMATER = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
static
{
TimeZone utc = TimeZone.getTimeZone("UTC");
ZULU_DATE_FORMATER.setTimeZone(utc); // ZULU_DATE_FORMAT format ends with Z for UTC so make that true
}
private String TAG = "OGT.KmzCreator";
public KmzCreator(Context context, Uri trackUri, String chosenFileName, ProgressListener listener)
{
super(context, trackUri, chosenFileName, listener);
}
@Override
protected Uri doInBackground(Void... params)
{
determineProgressGoal();
Uri resultFilename = exportKml();
return resultFilename;
}
private Uri exportKml()
{
if (mFileName.endsWith(".kmz") || mFileName.endsWith(".zip"))
{
setExportDirectoryPath(Constants.getSdCardDirectory(mContext) + mFileName.substring(0, mFileName.length() - 4));
}
else
{
setExportDirectoryPath(Constants.getSdCardDirectory(mContext) + mFileName);
}
new File(getExportDirectoryPath()).mkdirs();
String xmlFilePath = getExportDirectoryPath() + "/doc.kml";
String resultFilename = null;
FileOutputStream fos = null;
BufferedOutputStream buf = null;
try
{
verifySdCardAvailibility();
XmlSerializer serializer = Xml.newSerializer();
File xmlFile = new File(xmlFilePath);
fos = new FileOutputStream(xmlFile);
buf = new BufferedOutputStream(fos, 8192);
serializer.setOutput(buf, "UTF-8");
serializeTrack(mTrackUri, mFileName, serializer);
buf.close();
buf = null;
fos.close();
fos = null;
resultFilename = bundlingMediaAndXml(xmlFile.getParentFile().getName(), ".kmz");
mFileName = new File(resultFilename).getName();
}
catch (IllegalArgumentException e)
{
String text = mContext.getString(R.string.ticker_failed) + " \"" + xmlFilePath + "\" " + mContext.getString(R.string.error_filename);
handleError(mContext.getString(R.string.taskerror_kmz_write), e, text);
}
catch (IllegalStateException e)
{
String text = mContext.getString(R.string.ticker_failed) + " \"" + xmlFilePath + "\" " + mContext.getString(R.string.error_buildxml);
handleError(mContext.getString(R.string.taskerror_kmz_write), e, text);
}
catch (IOException e)
{
String text = mContext.getString(R.string.ticker_failed) + " \"" + xmlFilePath + "\" " + mContext.getString(R.string.error_writesdcard);
handleError(mContext.getString(R.string.taskerror_kmz_write), e, text);
}
finally
{
if (buf != null)
{
try
{
buf.close();
}
catch (IOException e)
{
Log.e(TAG, "Failed to close buf after completion, ignoring.", e);
}
}
if (fos != null)
{
try
{
fos.close();
}
catch (IOException e)
{
Log.e(TAG, "Failed to close fos after completion, ignoring.", e);
}
}
}
return Uri.fromFile(new File(resultFilename));
}
private void serializeTrack(Uri trackUri, String trackName, XmlSerializer serializer) throws IOException
{
serializer.startDocument("UTF-8", true);
serializer.setPrefix("xsi", NS_SCHEMA);
serializer.setPrefix("kml", NS_KML_22);
serializer.startTag("", "kml");
serializer.attribute(NS_SCHEMA, "schemaLocation", NS_KML_22 + " http://schemas.opengis.net/kml/2.2.0/ogckml22.xsd");
serializer.attribute(null, "xmlns", NS_KML_22);
serializer.text("\n");
serializer.startTag("", "Document");
serializer.text("\n");
quickTag(serializer, "", "name", trackName);
/* from <name/> upto <Folder/> */
serializeTrackHeader(serializer, trackUri);
serializer.text("\n");
serializer.endTag("", "Document");
serializer.endTag("", "kml");
serializer.endDocument();
}
private String serializeTrackHeader(XmlSerializer serializer, Uri trackUri) throws IOException
{
ContentResolver resolver = mContext.getContentResolver();
Cursor trackCursor = null;
String name = null;
try
{
trackCursor = resolver.query(trackUri, new String[] { Tracks.NAME }, null, null, null);
if (trackCursor.moveToFirst())
{
serializer.text("\n");
serializer.startTag("", "Style");
serializer.attribute(null, "id", "lineStyle");
serializer.startTag("", "LineStyle");
serializer.text("\n");
serializer.startTag("", "color");
serializer.text("99ffac59");
serializer.endTag("", "color");
serializer.text("\n");
serializer.startTag("", "width");
serializer.text("6");
serializer.endTag("", "width");
serializer.text("\n");
serializer.endTag("", "LineStyle");
serializer.text("\n");
serializer.endTag("", "Style");
serializer.text("\n");
serializer.startTag("", "Folder");
name = trackCursor.getString(0);
serializer.text("\n");
quickTag(serializer, "", "name", name);
serializer.text("\n");
serializer.startTag("", "open");
serializer.text("1");
serializer.endTag("", "open");
serializer.text("\n");
serializeSegments(serializer, Uri.withAppendedPath(trackUri, "segments"));
serializer.text("\n");
serializer.endTag("", "Folder");
}
}
finally
{
if (trackCursor != null)
{
trackCursor.close();
}
}
return name;
}
/**
* <pre>
* <Folder>
* <Placemark>
* serializeSegmentToTimespan()
* <LineString>
* serializeWaypoints()
* </LineString>
* </Placemark>
* <Placemark/>
* <Placemark/>
* </Folder>
* </pre>
*
* @param serializer
* @param segments
* @throws IOException
*/
private void serializeSegments(XmlSerializer serializer, Uri segments) throws IOException
{
Cursor segmentCursor = null;
ContentResolver resolver = mContext.getContentResolver();
try
{
segmentCursor = resolver.query(segments, new String[] { Segments._ID }, null, null, null);
if (segmentCursor.moveToFirst())
{
do
{
Uri waypoints = Uri.withAppendedPath(segments, segmentCursor.getLong(0) + "/waypoints");
serializer.text("\n");
serializer.startTag("", "Folder");
serializer.text("\n");
serializer.startTag("", "name");
serializer.text(String.format("Segment %d", 1 + segmentCursor.getPosition()));
serializer.endTag("", "name");
serializer.text("\n");
serializer.startTag("", "open");
serializer.text("1");
serializer.endTag("", "open");
/* Single <TimeSpan/> element */
serializeSegmentToTimespan(serializer, waypoints);
serializer.text("\n");
serializer.startTag("", "Placemark");
serializer.text("\n");
serializer.startTag("", "name");
serializer.text("Path");
serializer.endTag("", "name");
serializer.text("\n");
serializer.startTag("", "styleUrl");
serializer.text("#lineStyle");
serializer.endTag("", "styleUrl");
serializer.text("\n");
serializer.startTag("", "LineString");
serializer.text("\n");
serializer.startTag("", "tessellate");
serializer.text("0");
serializer.endTag("", "tessellate");
serializer.text("\n");
serializer.startTag("", "altitudeMode");
serializer.text("clampToGround");
serializer.endTag("", "altitudeMode");
/* Single <coordinates/> element */
serializeWaypoints(serializer, waypoints);
serializer.text("\n");
serializer.endTag("", "LineString");
serializer.text("\n");
serializer.endTag("", "Placemark");
serializeWaypointDescription(serializer, Uri.withAppendedPath(segments, "/" + segmentCursor.getLong(0) + "/media"));
serializer.text("\n");
serializer.endTag("", "Folder");
}
while (segmentCursor.moveToNext());
}
}
finally
{
if (segmentCursor != null)
{
segmentCursor.close();
}
}
}
/**
* <TimeSpan><begin>...</begin><end>...</end></TimeSpan>
*
* @param serializer
* @param waypoints
* @throws IOException
*/
private void serializeSegmentToTimespan(XmlSerializer serializer, Uri waypoints) throws IOException
{
Cursor waypointsCursor = null;
Date segmentStartTime = null;
Date segmentEndTime = null;
ContentResolver resolver = mContext.getContentResolver();
try
{
waypointsCursor = resolver.query(waypoints, new String[] { Waypoints.TIME }, null, null, null);
if (waypointsCursor.moveToFirst())
{
segmentStartTime = new Date(waypointsCursor.getLong(0));
if (waypointsCursor.moveToLast())
{
segmentEndTime = new Date(waypointsCursor.getLong(0));
serializer.text("\n");
serializer.startTag("", "TimeSpan");
serializer.text("\n");
serializer.startTag("", "begin");
synchronized (ZULU_DATE_FORMATER)
{
serializer.text(ZULU_DATE_FORMATER.format(segmentStartTime));
serializer.endTag("", "begin");
serializer.text("\n");
serializer.startTag("", "end");
serializer.text(ZULU_DATE_FORMATER.format(segmentEndTime));
}
serializer.endTag("", "end");
serializer.text("\n");
serializer.endTag("", "TimeSpan");
}
}
}
finally
{
if (waypointsCursor != null)
{
waypointsCursor.close();
}
}
}
/**
* <coordinates>...</coordinates>
*
* @param serializer
* @param waypoints
* @throws IOException
*/
private void serializeWaypoints(XmlSerializer serializer, Uri waypoints) throws IOException
{
Cursor waypointsCursor = null;
ContentResolver resolver = mContext.getContentResolver();
try
{
waypointsCursor = resolver.query(waypoints, new String[] { Waypoints.LONGITUDE, Waypoints.LATITUDE, Waypoints.ALTITUDE }, null, null, null);
if (waypointsCursor.moveToFirst())
{
serializer.text("\n");
serializer.startTag("", "coordinates");
do
{
mProgressAdmin.addWaypointProgress(1);
// Single Coordinate tuple
serializeCoordinates(serializer, waypointsCursor);
serializer.text(" ");
}
while (waypointsCursor.moveToNext());
serializer.endTag("", "coordinates");
}
}
finally
{
if (waypointsCursor != null)
{
waypointsCursor.close();
}
}
}
/**
* lon,lat,alt tuple without trailing spaces
*
* @param serializer
* @param waypointsCursor
* @throws IOException
*/
private void serializeCoordinates(XmlSerializer serializer, Cursor waypointsCursor) throws IOException
{
serializer.text(Double.toString(waypointsCursor.getDouble(0)));
serializer.text(",");
serializer.text(Double.toString(waypointsCursor.getDouble(1)));
serializer.text(",");
serializer.text(Double.toString(waypointsCursor.getDouble(2)));
}
private void serializeWaypointDescription(XmlSerializer serializer, Uri media) throws IOException
{
String mediaPathPrefix = Constants.getSdCardDirectory(mContext);
Cursor mediaCursor = null;
ContentResolver resolver = mContext.getContentResolver();
BufferedReader buf = null;
try
{
mediaCursor = resolver.query(media, new String[] { Media.URI, Media.TRACK, Media.SEGMENT, Media.WAYPOINT }, null, null, null);
if (mediaCursor.moveToFirst())
{
do
{
Uri mediaUri = Uri.parse(mediaCursor.getString(0));
Uri singleWaypointUri = Uri.withAppendedPath(Tracks.CONTENT_URI, mediaCursor.getLong(1) + "/segments/" + mediaCursor.getLong(2) + "/waypoints/"
+ mediaCursor.getLong(3));
String lastPathSegment = mediaUri.getLastPathSegment();
if (mediaUri.getScheme().equals("file"))
{
if (lastPathSegment.endsWith("3gp"))
{
String includedMediaFile = includeMediaFile(lastPathSegment);
serializer.text("\n");
serializer.startTag("", "Placemark");
serializer.text("\n");
quickTag(serializer, "", "name", lastPathSegment);
serializer.text("\n");
serializer.startTag("", "description");
String kmlAudioUnsupported = mContext.getString(R.string.kmlVideoUnsupported);
serializer.text(String.format(kmlAudioUnsupported, includedMediaFile));
serializer.endTag("", "description");
serializeMediaPoint(serializer, singleWaypointUri);
serializer.text("\n");
serializer.endTag("", "Placemark");
}
else if (lastPathSegment.endsWith("jpg"))
{
String includedMediaFile = includeMediaFile(mediaPathPrefix + lastPathSegment);
serializer.text("\n");
serializer.startTag("", "Placemark");
serializer.text("\n");
quickTag(serializer, "", "name", lastPathSegment);
serializer.text("\n");
quickTag(serializer, "", "description", "<img src=\"" + includedMediaFile + "\" width=\"500px\"/><br/>" + lastPathSegment);
serializer.text("\n");
serializeMediaPoint(serializer, singleWaypointUri);
serializer.text("\n");
serializer.endTag("", "Placemark");
}
else if (lastPathSegment.endsWith("txt"))
{
serializer.text("\n");
serializer.startTag("", "Placemark");
serializer.text("\n");
quickTag(serializer, "", "name", lastPathSegment);
serializer.text("\n");
serializer.startTag("", "description");
if(buf != null ) buf.close();
buf = new BufferedReader(new FileReader(mediaUri.getEncodedPath()));
String line;
while ((line = buf.readLine()) != null)
{
serializer.text(line);
serializer.text("\n");
}
serializer.endTag("", "description");
serializeMediaPoint(serializer, singleWaypointUri);
serializer.text("\n");
serializer.endTag("", "Placemark");
}
}
else if (mediaUri.getScheme().equals("content"))
{
if (mediaUri.getAuthority().equals(GPStracking.AUTHORITY + ".string"))
{
serializer.text("\n");
serializer.startTag("", "Placemark");
serializer.text("\n");
quickTag(serializer, "", "name", lastPathSegment);
serializeMediaPoint(serializer, singleWaypointUri);
serializer.text("\n");
serializer.endTag("", "Placemark");
}
else if (mediaUri.getAuthority().equals("media"))
{
Cursor mediaItemCursor = null;
try
{
mediaItemCursor = resolver.query(mediaUri, new String[] { MediaColumns.DATA, MediaColumns.DISPLAY_NAME }, null, null, null);
if (mediaItemCursor.moveToFirst())
{
String includedMediaFile = includeMediaFile(mediaItemCursor.getString(0));
serializer.text("\n");
serializer.startTag("", "Placemark");
serializer.text("\n");
quickTag(serializer, "", "name", mediaItemCursor.getString(1));
serializer.text("\n");
serializer.startTag("", "description");
String kmlAudioUnsupported = mContext.getString(R.string.kmlAudioUnsupported);
serializer.text(String.format(kmlAudioUnsupported, includedMediaFile));
serializer.endTag("", "description");
serializeMediaPoint(serializer, singleWaypointUri);
serializer.text("\n");
serializer.endTag("", "Placemark");
}
}
finally
{
if (mediaItemCursor != null)
{
mediaItemCursor.close();
}
}
}
}
}
while (mediaCursor.moveToNext());
}
}
finally
{
if (mediaCursor != null)
{
mediaCursor.close();
}
if(buf != null ) buf.close();
}
}
/**
* <Point>...</Point> <shape>rectangle</shape>
*
* @param serializer
* @param singleWaypointUri
* @throws IllegalArgumentException
* @throws IllegalStateException
* @throws IOException
*/
private void serializeMediaPoint(XmlSerializer serializer, Uri singleWaypointUri) throws IllegalArgumentException, IllegalStateException, IOException
{
Cursor waypointsCursor = null;
ContentResolver resolver = mContext.getContentResolver();
try
{
waypointsCursor = resolver.query(singleWaypointUri, new String[] { Waypoints.LONGITUDE, Waypoints.LATITUDE, Waypoints.ALTITUDE }, null, null, null);
if (waypointsCursor.moveToFirst())
{
serializer.text("\n");
serializer.startTag("", "Point");
serializer.text("\n");
serializer.startTag("", "coordinates");
serializeCoordinates(serializer, waypointsCursor);
serializer.endTag("", "coordinates");
serializer.text("\n");
serializer.endTag("", "Point");
serializer.text("\n");
}
}
finally
{
if (waypointsCursor != null)
{
waypointsCursor.close();
}
}
}
@Override
protected String getContentType()
{
return "application/vnd.google-earth.kmz";
}
@Override
public boolean needsBundling()
{
return true;
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/tasks/KmzCreator.java | Java | gpl3 | 23,091 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Jul 9, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.tasks;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.ShareTrack;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.db.GPStracking;
import nl.sogeti.android.gpstracker.db.GPStracking.Media;
import nl.sogeti.android.gpstracker.db.GPStracking.MetaData;
import nl.sogeti.android.gpstracker.oauth.PrepareRequestTokenActivity;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.viewer.map.LoggerMapHelper;
import oauth.signpost.commonshttp.CommonsHttpOAuthConsumer;
import oauth.signpost.exception.OAuthCommunicationException;
import oauth.signpost.exception.OAuthExpectationFailedException;
import oauth.signpost.exception.OAuthMessageSignerException;
import org.apache.ogt.http.HttpEntity;
import org.apache.ogt.http.HttpException;
import org.apache.ogt.http.HttpResponse;
import org.apache.ogt.http.client.methods.HttpPost;
import org.apache.ogt.http.entity.mime.HttpMultipartMode;
import org.apache.ogt.http.entity.mime.MultipartEntity;
import org.apache.ogt.http.entity.mime.content.FileBody;
import org.apache.ogt.http.entity.mime.content.StringBody;
import org.apache.ogt.http.impl.client.DefaultHttpClient;
import org.apache.ogt.http.util.EntityUtils;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.database.Cursor;
import android.net.Uri;
import android.preference.PreferenceManager;
import android.util.Log;
import android.widget.Toast;
/**
* ????
*
* @version $Id:$
* @author rene (c) Jul 9, 2011, Sogeti B.V.
*/
public class OsmSharing extends GpxCreator
{
public static final String OAUTH_TOKEN = "openstreetmap_oauth_token";
public static final String OAUTH_TOKEN_SECRET = "openstreetmap_oauth_secret";
private static final String TAG = "OGT.OsmSharing";
public static final String OSM_FILENAME = "OSM_Trace";
private String responseText;
private Uri mFileUri;
public OsmSharing(Activity context, Uri trackUri, boolean attachments, ProgressListener listener)
{
super(context, trackUri, OSM_FILENAME, attachments, listener);
}
public void resumeOsmSharing(Uri fileUri, Uri trackUri)
{
mFileUri = fileUri;
mTrackUri = trackUri;
execute();
}
@Override
protected Uri doInBackground(Void... params)
{
if( mFileUri == null )
{
mFileUri = super.doInBackground(params);
}
sendToOsm(mFileUri, mTrackUri);
return mFileUri;
}
@Override
protected void onPostExecute(Uri resultFilename)
{
super.onPostExecute(resultFilename);
CharSequence text = mContext.getString(R.string.osm_success) + responseText;
Toast toast = Toast.makeText(mContext, text, Toast.LENGTH_LONG);
toast.show();
}
/**
* POST a (GPX) file to the 0.6 API of the OpenStreetMap.org website
* publishing this track to the public.
*
* @param fileUri
* @param contentType
*/
private void sendToOsm(final Uri fileUri, final Uri trackUri)
{
CommonsHttpOAuthConsumer consumer = osmConnectionSetup();
if( consumer == null )
{
requestOpenstreetmapOauthToken();
handleError(mContext.getString(R.string.osm_task), null, mContext.getString(R.string.osmauth_message));
}
String visibility = PreferenceManager.getDefaultSharedPreferences(mContext).getString(Constants.OSM_VISIBILITY, "trackable");
File gpxFile = new File(fileUri.getEncodedPath());
String url = mContext.getString(R.string.osm_post_url);
DefaultHttpClient httpclient = new DefaultHttpClient();
HttpResponse response = null;
int statusCode = 0;
Cursor metaData = null;
String sources = null;
HttpEntity responseEntity = null;
try
{
metaData = mContext.getContentResolver().query(Uri.withAppendedPath(trackUri, "metadata"), new String[] { MetaData.VALUE }, MetaData.KEY + " = ? ",
new String[] { Constants.DATASOURCES_KEY }, null);
if (metaData.moveToFirst())
{
sources = metaData.getString(0);
}
if (sources != null && sources.contains(LoggerMapHelper.GOOGLE_PROVIDER))
{
throw new IOException("Unable to upload track with materials derived from Google Maps.");
}
// The POST to the create node
HttpPost method = new HttpPost(url);
String tags = mContext.getString(R.string.osm_tag) + " " +queryForNotes();
// Build the multipart body with the upload data
MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
entity.addPart("file", new FileBody(gpxFile));
entity.addPart("description", new StringBody( ShareTrack.queryForTrackName(mContext.getContentResolver(), mTrackUri)));
entity.addPart("tags", new StringBody(tags));
entity.addPart("visibility", new StringBody(visibility));
method.setEntity(entity);
// Execute the POST to OpenStreetMap
consumer.sign(method);
response = httpclient.execute(method);
// Read the response
statusCode = response.getStatusLine().getStatusCode();
responseEntity = response.getEntity();
InputStream stream = responseEntity.getContent();
responseText = XmlCreator.convertStreamToString(stream);
}
catch (OAuthMessageSignerException e)
{
Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
editor.remove(OAUTH_TOKEN);
editor.remove(OAUTH_TOKEN_SECRET);
editor.commit();
responseText = mContext.getString(R.string.osm_failed) + e.getLocalizedMessage();
handleError(mContext.getString(R.string.osm_task), e, responseText);
}
catch (OAuthExpectationFailedException e)
{
Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
editor.remove(OAUTH_TOKEN);
editor.remove(OAUTH_TOKEN_SECRET);
editor.commit();
responseText = mContext.getString(R.string.osm_failed) + e.getLocalizedMessage();
handleError(mContext.getString(R.string.osm_task), e, responseText);
}
catch (OAuthCommunicationException e)
{
Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
editor.remove(OAUTH_TOKEN);
editor.remove(OAUTH_TOKEN_SECRET);
editor.commit();
responseText = mContext.getString(R.string.osm_failed) + e.getLocalizedMessage();
handleError(mContext.getString(R.string.osm_task), e, responseText);
}
catch (IOException e)
{
responseText = mContext.getString(R.string.osm_failed) + e.getLocalizedMessage();
handleError(mContext.getString(R.string.osm_task), e, responseText);
}
finally
{
if (responseEntity != null)
{
try
{
EntityUtils.consume(responseEntity);
}
catch (IOException e)
{
Log.e(TAG, "Failed to close the content stream", e);
}
}
if (metaData != null)
{
metaData.close();
}
}
if (statusCode != 200)
{
Log.e(TAG, "Failed to upload to error code " + statusCode + " " + responseText);
String text = mContext.getString(R.string.osm_failed) + responseText;
if( statusCode == 401 )
{
Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
editor.remove(OAUTH_TOKEN);
editor.remove(OAUTH_TOKEN_SECRET);
editor.commit();
}
handleError(mContext.getString(R.string.osm_task), new HttpException("Unexpected status reported by OSM"), text);
}
}
private CommonsHttpOAuthConsumer osmConnectionSetup()
{
final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
String token = prefs.getString(OAUTH_TOKEN, "");
String secret = prefs.getString(OAUTH_TOKEN_SECRET, "");
boolean mAuthorized = !"".equals(token) && !"".equals(secret);
CommonsHttpOAuthConsumer consumer = null;
if (mAuthorized)
{
consumer = new CommonsHttpOAuthConsumer(mContext.getString(R.string.OSM_CONSUMER_KEY), mContext.getString(R.string.OSM_CONSUMER_SECRET));
consumer.setTokenWithSecret(token, secret);
}
return consumer;
}
private String queryForNotes()
{
StringBuilder tags = new StringBuilder();
ContentResolver resolver = mContext.getContentResolver();
Cursor mediaCursor = null;
Uri mediaUri = Uri.withAppendedPath(mTrackUri, "media");
try
{
mediaCursor = resolver.query(mediaUri, new String[] { Media.URI }, null, null, null);
if (mediaCursor.moveToFirst())
{
do
{
Uri noteUri = Uri.parse(mediaCursor.getString(0));
if (noteUri.getScheme().equals("content") && noteUri.getAuthority().equals(GPStracking.AUTHORITY + ".string"))
{
String tag = noteUri.getLastPathSegment().trim();
if (!tag.contains(" "))
{
if (tags.length() > 0)
{
tags.append(" ");
}
tags.append(tag);
}
}
}
while (mediaCursor.moveToNext());
}
}
finally
{
if (mediaCursor != null)
{
mediaCursor.close();
}
}
return tags.toString();
}
public void requestOpenstreetmapOauthToken()
{
Intent intent = new Intent(mContext.getApplicationContext(), PrepareRequestTokenActivity.class);
intent.putExtra(PrepareRequestTokenActivity.OAUTH_TOKEN_PREF, OAUTH_TOKEN);
intent.putExtra(PrepareRequestTokenActivity.OAUTH_TOKEN_SECRET_PREF, OAUTH_TOKEN_SECRET);
intent.putExtra(PrepareRequestTokenActivity.CONSUMER_KEY, mContext.getString(R.string.OSM_CONSUMER_KEY));
intent.putExtra(PrepareRequestTokenActivity.CONSUMER_SECRET, mContext.getString(R.string.OSM_CONSUMER_SECRET));
intent.putExtra(PrepareRequestTokenActivity.REQUEST_URL, Constants.OSM_REQUEST_URL);
intent.putExtra(PrepareRequestTokenActivity.ACCESS_URL, Constants.OSM_ACCESS_URL);
intent.putExtra(PrepareRequestTokenActivity.AUTHORIZE_URL, Constants.OSM_AUTHORIZE_URL);
mContext.startActivity(intent);
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/tasks/OsmSharing.java | Java | gpl3 | 12,525 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Jul 9, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions.tasks;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.ShareTrack;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import android.content.Context;
import android.net.Uri;
/**
* ????
*
* @version $Id:$
* @author rene (c) Jul 9, 2011, Sogeti B.V.
*/
public class GpxSharing extends GpxCreator
{
public GpxSharing(Context context, Uri trackUri, String chosenBaseFileName, boolean attachments, ProgressListener listener)
{
super(context, trackUri, chosenBaseFileName, attachments, listener);
}
@Override
protected void onPostExecute(Uri resultFilename)
{
super.onPostExecute(resultFilename);
ShareTrack.sendFile(mContext, resultFilename, mContext.getString(R.string.email_gpxbody), getContentType());
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/tasks/GpxSharing.java | Java | gpl3 | 2,365 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions;
import java.util.List;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.breadcrumbs.BreadcrumbsService;
import nl.sogeti.android.gpstracker.breadcrumbs.BreadcrumbsService.LocalBinder;
import nl.sogeti.android.gpstracker.breadcrumbs.BreadcrumbsTracks;
import nl.sogeti.android.gpstracker.db.GPStracking.MetaData;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.Pair;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.content.ComponentName;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnDismissListener;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.net.Uri;
import android.os.Bundle;
import android.os.IBinder;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.ProgressBar;
import android.widget.Spinner;
import android.widget.SpinnerAdapter;
/**
* Empty Activity that pops up the dialog to describe the track
*
* @version $Id: NameTrack.java 888 2011-03-14 19:44:44Z rcgroot@gmail.com $
* @author rene (c) Jul 27, 2010, Sogeti B.V.
*/
public class DescribeTrack extends Activity
{
private static final int DIALOG_TRACKDESCRIPTION = 42;
protected static final String TAG = "OGT.DescribeTrack";
private static final String ACTIVITY_ID = "ACTIVITY_ID";
private static final String BUNDLE_ID = "BUNDLE_ID";
private Spinner mActivitySpinner;
private Spinner mBundleSpinner;
private EditText mDescriptionText;
private CheckBox mPublicCheck;
private Button mOkayButton;
private boolean paused;
private Uri mTrackUri;
private ProgressBar mProgressSpinner;
private AlertDialog mDialog;
private BreadcrumbsService mService;
boolean mBound = false;
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
this.setVisible(false);
paused = false;
mTrackUri = this.getIntent().getData();
Intent service = new Intent(this, BreadcrumbsService.class);
startService(service);
}
@Override
protected void onStart()
{
super.onStart();
Intent intent = new Intent(this, BreadcrumbsService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}
/*
* (non-Javadoc)
* @see com.google.android.maps.MapActivity#onPause()
*/
@Override
protected void onResume()
{
super.onResume();
if (mTrackUri != null)
{
showDialog(DIALOG_TRACKDESCRIPTION);
}
else
{
Log.e(TAG, "Describing track without a track URI supplied.");
finish();
}
}
@Override
protected void onPause()
{
super.onPause();
paused = true;
}
@Override
protected void onStop()
{
if (mBound)
{
unbindService(mConnection);
mBound = false;
mService = null;
}
super.onStop();
}
@Override
protected void onDestroy()
{
if (isFinishing())
{
Intent service = new Intent(this, BreadcrumbsService.class);
stopService(service);
}
super.onDestroy();
}
@Override
protected Dialog onCreateDialog(int id)
{
LayoutInflater factory = null;
View view = null;
Builder builder = null;
switch (id)
{
case DIALOG_TRACKDESCRIPTION:
builder = new AlertDialog.Builder(this);
factory = LayoutInflater.from(this);
view = factory.inflate(R.layout.describedialog, null);
mActivitySpinner = (Spinner) view.findViewById(R.id.activity);
mBundleSpinner = (Spinner) view.findViewById(R.id.bundle);
mDescriptionText = (EditText) view.findViewById(R.id.description);
mPublicCheck = (CheckBox) view.findViewById(R.id.public_checkbox);
mProgressSpinner = (ProgressBar) view.findViewById(R.id.progressSpinner);
builder.setTitle(R.string.dialog_description_title).setMessage(R.string.dialog_description_message).setIcon(android.R.drawable.ic_dialog_alert)
.setPositiveButton(R.string.btn_okay, mTrackDescriptionDialogListener).setNegativeButton(R.string.btn_cancel, mTrackDescriptionDialogListener).setView(view);
mDialog = builder.create();
setUiEnabled();
mDialog.setOnDismissListener(new OnDismissListener()
{
@Override
public void onDismiss(DialogInterface dialog)
{
if (!paused)
{
finish();
}
}
});
return mDialog;
default:
return super.onCreateDialog(id);
}
}
@Override
protected void onPrepareDialog(int id, Dialog dialog)
{
switch (id)
{
case DIALOG_TRACKDESCRIPTION:
setUiEnabled();
connectBreadcrumbs();
break;
default:
super.onPrepareDialog(id, dialog);
break;
}
}
private void connectBreadcrumbs()
{
if (mService != null && !mService.isAuthorized())
{
mService.collectBreadcrumbsOauthToken();
}
}
private void saveBreadcrumbsPreference(int activityPosition, int bundlePosition)
{
Editor editor = PreferenceManager.getDefaultSharedPreferences(this).edit();
editor.putInt(ACTIVITY_ID, activityPosition);
editor.putInt(BUNDLE_ID, bundlePosition);
editor.commit();
}
private void loadBreadcrumbsPreference()
{
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
int activityPos = prefs.getInt(ACTIVITY_ID, 0);
activityPos = activityPos < mActivitySpinner.getCount() ? activityPos : 0;
mActivitySpinner.setSelection(activityPos);
int bundlePos = prefs.getInt(BUNDLE_ID, 0);
bundlePos = bundlePos < mBundleSpinner.getCount() ? bundlePos : 0;
mBundleSpinner.setSelection(bundlePos);
}
private ContentValues buildContentValues(String key, String value)
{
ContentValues contentValues = new ContentValues();
contentValues.put(MetaData.KEY, key);
contentValues.put(MetaData.VALUE, value);
return contentValues;
}
private void setUiEnabled()
{
boolean enabled = mService != null && mService.isAuthorized();
if (mProgressSpinner != null)
{
if (enabled)
{
mProgressSpinner.setVisibility(View.GONE);
}
else
{
mProgressSpinner.setVisibility(View.VISIBLE);
}
}
if (mDialog != null)
{
mOkayButton = mDialog.getButton(AlertDialog.BUTTON_POSITIVE);
}
for (View view : new View[] { mActivitySpinner, mBundleSpinner, mDescriptionText, mPublicCheck, mOkayButton })
{
if (view != null)
{
view.setEnabled(enabled);
}
}
if (enabled)
{
mActivitySpinner.setAdapter(getActivityAdapter());
mBundleSpinner.setAdapter(getBundleAdapter());
loadBreadcrumbsPreference();
}
}
public SpinnerAdapter getActivityAdapter()
{
List<Pair<Integer, Integer>> activities = mService.getActivityList();
ArrayAdapter<Pair<Integer, Integer>> adapter = new ArrayAdapter<Pair<Integer, Integer>>(this, android.R.layout.simple_spinner_item, activities);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
return adapter;
}
public SpinnerAdapter getBundleAdapter()
{
List<Pair<Integer, Integer>> bundles = mService.getBundleList();
ArrayAdapter<Pair<Integer, Integer>> adapter = new ArrayAdapter<Pair<Integer, Integer>>(this, android.R.layout.simple_spinner_item, bundles);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
return adapter;
}
private ServiceConnection mConnection = new ServiceConnection()
{
@Override
public void onServiceConnected(ComponentName className, IBinder service)
{
// We've bound to LocalService, cast the IBinder and get LocalService instance
LocalBinder binder = (LocalBinder) service;
mService = binder.getService();
mBound = true;
setUiEnabled();
}
@Override
public void onServiceDisconnected(ComponentName arg0)
{
mService = null;
mBound = false;
}
};
private final DialogInterface.OnClickListener mTrackDescriptionDialogListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
switch (which)
{
case DialogInterface.BUTTON_POSITIVE:
Uri metadataUri = Uri.withAppendedPath(mTrackUri, "metadata");
Integer activityId = ((Pair<Integer, Integer>)mActivitySpinner.getSelectedItem()).second;
Integer bundleId = ((Pair<Integer, Integer>)mBundleSpinner.getSelectedItem()).second;
saveBreadcrumbsPreference(mActivitySpinner.getSelectedItemPosition(), mBundleSpinner.getSelectedItemPosition());
String description = mDescriptionText.getText().toString();
String isPublic = Boolean.toString(mPublicCheck.isChecked());
ContentValues[] metaValues = { buildContentValues(BreadcrumbsTracks.ACTIVITY_ID, activityId.toString()), buildContentValues(BreadcrumbsTracks.BUNDLE_ID, bundleId.toString()),
buildContentValues(BreadcrumbsTracks.DESCRIPTION, description), buildContentValues(BreadcrumbsTracks.ISPUBLIC, isPublic), };
getContentResolver().bulkInsert(metadataUri, metaValues);
Intent data = new Intent();
data.setData(mTrackUri);
if (getIntent().getExtras() != null && getIntent().getExtras().containsKey(Constants.NAME))
{
data.putExtra(Constants.NAME, getIntent().getExtras().getString(Constants.NAME));
}
setResult(RESULT_OK, data);
break;
case DialogInterface.BUTTON_NEGATIVE:
break;
default:
Log.e(TAG, "Unknown option ending dialog:" + which);
break;
}
finish();
}
};
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/DescribeTrack.java | Java | gpl3 | 12,639 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.logger.GPSLoggerServiceManager;
import nl.sogeti.android.gpstracker.util.Constants;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.content.ComponentName;
import android.content.ContentUris;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.DialogInterface.OnDismissListener;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Button;
/**
* Empty Activity that pops up the dialog to name the track
*
* @version $Id$
* @author rene (c) Jul 27, 2010, Sogeti B.V.
*/
public class ControlTracking extends Activity
{
private static final int DIALOG_LOGCONTROL = 26;
private static final String TAG = "OGT.ControlTracking";
private GPSLoggerServiceManager mLoggerServiceManager;
private Button start;
private Button pause;
private Button resume;
private Button stop;
private boolean paused;
private final View.OnClickListener mLoggingControlListener = new View.OnClickListener()
{
@Override
public void onClick( View v )
{
int id = v.getId();
Intent intent = new Intent();
switch( id )
{
case R.id.logcontrol_start:
long loggerTrackId = mLoggerServiceManager.startGPSLogging( null );
// Start a naming of the track
Intent namingIntent = new Intent( ControlTracking.this, NameTrack.class );
namingIntent.setData( ContentUris.withAppendedId( Tracks.CONTENT_URI, loggerTrackId ) );
startActivity( namingIntent );
// Create data for the caller that a new track has been started
ComponentName caller = ControlTracking.this.getCallingActivity();
if( caller != null )
{
intent.setData( ContentUris.withAppendedId( Tracks.CONTENT_URI, loggerTrackId ) );
setResult( RESULT_OK, intent );
}
break;
case R.id.logcontrol_pause:
mLoggerServiceManager.pauseGPSLogging();
setResult( RESULT_OK, intent );
break;
case R.id.logcontrol_resume:
mLoggerServiceManager.resumeGPSLogging();
setResult( RESULT_OK, intent );
break;
case R.id.logcontrol_stop:
mLoggerServiceManager.stopGPSLogging();
setResult( RESULT_OK, intent );
break;
default:
setResult( RESULT_CANCELED, intent );
break;
}
finish();
}
};
private OnClickListener mDialogClickListener = new OnClickListener()
{
@Override
public void onClick( DialogInterface dialog, int which )
{
setResult( RESULT_CANCELED, new Intent() );
finish();
}
};
@Override
protected void onCreate( Bundle savedInstanceState )
{
super.onCreate( savedInstanceState );
this.setVisible( false );
paused = false;
mLoggerServiceManager = new GPSLoggerServiceManager( this );
}
@Override
protected void onResume()
{
super.onResume();
mLoggerServiceManager.startup( this, new Runnable()
{
@Override
public void run()
{
showDialog( DIALOG_LOGCONTROL );
}
} );
}
@Override
protected void onPause()
{
super.onPause();
mLoggerServiceManager.shutdown( this );
paused = true;
}
@Override
protected Dialog onCreateDialog( int id )
{
Dialog dialog = null;
LayoutInflater factory = null;
View view = null;
Builder builder = null;
switch( id )
{
case DIALOG_LOGCONTROL:
builder = new AlertDialog.Builder( this );
factory = LayoutInflater.from( this );
view = factory.inflate( R.layout.logcontrol, null );
builder.setTitle( R.string.dialog_tracking_title ).
setIcon( android.R.drawable.ic_dialog_alert ).
setNegativeButton( R.string.btn_cancel, mDialogClickListener ).
setView( view );
dialog = builder.create();
start = (Button) view.findViewById( R.id.logcontrol_start );
pause = (Button) view.findViewById( R.id.logcontrol_pause );
resume = (Button) view.findViewById( R.id.logcontrol_resume );
stop = (Button) view.findViewById( R.id.logcontrol_stop );
start.setOnClickListener( mLoggingControlListener );
pause.setOnClickListener( mLoggingControlListener );
resume.setOnClickListener( mLoggingControlListener );
stop.setOnClickListener( mLoggingControlListener );
dialog.setOnDismissListener( new OnDismissListener()
{
@Override
public void onDismiss( DialogInterface dialog )
{
if( !paused )
{
finish();
}
}
});
return dialog;
default:
return super.onCreateDialog( id );
}
}
/*
* (non-Javadoc)
* @see android.app.Activity#onPrepareDialog(int, android.app.Dialog)
*/
@Override
protected void onPrepareDialog( int id, Dialog dialog )
{
switch( id )
{
case DIALOG_LOGCONTROL:
updateDialogState( mLoggerServiceManager.getLoggingState() );
break;
default:
break;
}
super.onPrepareDialog( id, dialog );
}
private void updateDialogState( int state )
{
switch( state )
{
case Constants.STOPPED:
start.setEnabled( true );
pause.setEnabled( false );
resume.setEnabled( false );
stop.setEnabled( false );
break;
case Constants.LOGGING:
start.setEnabled( false );
pause.setEnabled( true );
resume.setEnabled( false );
stop.setEnabled( true );
break;
case Constants.PAUSED:
start.setEnabled( false );
pause.setEnabled( false );
resume.setEnabled( true );
stop.setEnabled( true );
break;
default:
Log.w( TAG, String.format( "State %d of logging, enabling and hope for the best....", state ) );
start.setEnabled( false );
pause.setEnabled( false );
resume.setEnabled( false );
stop.setEnabled( false );
break;
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/ControlTracking.java | Java | gpl3 | 8,784 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Calendar;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.logger.GPSLoggerServiceManager;
import nl.sogeti.android.gpstracker.util.Constants;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.content.ActivityNotFoundException;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.DialogInterface.OnDismissListener;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
/**
* Empty Activity that pops up the dialog to add a note to the most current
* point in the logger service
*
* @version $Id$
* @author rene (c) Jul 27, 2010, Sogeti B.V.
*/
public class InsertNote extends Activity
{
private static final int DIALOG_INSERTNOTE = 27;
private static final String TAG = "OGT.InsertNote";
private static final int MENU_PICTURE = 9;
private static final int MENU_VOICE = 11;
private static final int MENU_VIDEO = 12;
private static final int DIALOG_TEXT = 32;
private static final int DIALOG_NAME = 33;
private GPSLoggerServiceManager mLoggerServiceManager;
/**
* Action to take when the LoggerService is bound
*/
private Runnable mServiceBindAction;
private boolean paused;
private Button name;
private Button text;
private Button voice;
private Button picture;
private Button video;
private EditText mNoteNameView;
private EditText mNoteTextView;
private final OnClickListener mNoteTextDialogListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
String noteText = mNoteTextView.getText().toString();
Calendar c = Calendar.getInstance();
String newName = String.format("Textnote_%tY-%tm-%td_%tH%tM%tS.txt", c, c, c, c, c, c);
File file = new File(Constants.getSdCardDirectory(InsertNote.this) + newName);
FileWriter filewriter = null;
try
{
file.getParentFile().mkdirs();
file.createNewFile();
filewriter = new FileWriter(file);
filewriter.append(noteText);
filewriter.flush();
}
catch (IOException e)
{
Log.e(TAG, "Note storing failed", e);
CharSequence text = e.getLocalizedMessage();
Toast toast = Toast.makeText(InsertNote.this, text, Toast.LENGTH_LONG);
toast.show();
}
finally
{
if (filewriter != null)
{
try
{
filewriter.close();
}
catch (IOException e)
{ /* */
}
}
}
InsertNote.this.mLoggerServiceManager.storeMediaUri(Uri.fromFile(file));
setResult(RESULT_CANCELED, new Intent());
finish();
}
};
private final OnClickListener mNoteNameDialogListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
String name = mNoteNameView.getText().toString();
Uri media = Uri.withAppendedPath(Constants.NAME_URI, Uri.encode(name));
InsertNote.this.mLoggerServiceManager.storeMediaUri(media);
setResult(RESULT_CANCELED, new Intent());
finish();
}
};
private final View.OnClickListener mNoteInsertListener = new View.OnClickListener()
{
@Override
public void onClick(View v)
{
int id = v.getId();
switch (id)
{
case R.id.noteinsert_picture:
addPicture();
break;
case R.id.noteinsert_video:
addVideo();
break;
case R.id.noteinsert_voice:
addVoice();
break;
case R.id.noteinsert_text:
showDialog(DIALOG_TEXT);
break;
case R.id.noteinsert_name:
showDialog(DIALOG_NAME);
break;
default:
setResult(RESULT_CANCELED, new Intent());
finish();
break;
}
}
};
private OnClickListener mDialogClickListener = new OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
setResult(RESULT_CANCELED, new Intent());
finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
this.setVisible(false);
paused = false;
mLoggerServiceManager = new GPSLoggerServiceManager(this);
}
@Override
protected void onResume()
{
super.onResume();
if (mServiceBindAction == null)
{
mServiceBindAction = new Runnable()
{
@Override
public void run()
{
showDialog(DIALOG_INSERTNOTE);
}
};
}
;
mLoggerServiceManager.startup(this, mServiceBindAction);
}
@Override
protected void onPause()
{
super.onPause();
mLoggerServiceManager.shutdown(this);
paused = true;
}
/*
* (non-Javadoc)
* @see android.app.Activity#onActivityResult(int, int,
* android.content.Intent)
*/
@Override
protected void onActivityResult(final int requestCode, final int resultCode, final Intent intent)
{
super.onActivityResult(requestCode, resultCode, intent);
mServiceBindAction = new Runnable()
{
@Override
public void run()
{
if (resultCode != RESULT_CANCELED)
{
File file;
Uri uri;
File newFile;
String newName;
Uri fileUri;
android.net.Uri.Builder builder;
boolean isLocal = false;
switch (requestCode)
{
case MENU_PICTURE:
file = new File(Constants.getSdCardTmpFile(InsertNote.this));
Calendar c = Calendar.getInstance();
newName = String.format("Picture_%tY-%tm-%td_%tH%tM%tS.jpg", c, c, c, c, c, c);
newFile = new File(Constants.getSdCardDirectory(InsertNote.this) + newName);
file.getParentFile().mkdirs();
isLocal = file.renameTo(newFile); //
if (!isLocal)
{
Log.w(TAG, "Failed rename will try copy image: " + file.getAbsolutePath());
isLocal = copyFile(file, newFile);
}
if (isLocal)
{
System.gc();
Options opts = new Options();
opts.inJustDecodeBounds = true;
Bitmap bm = BitmapFactory.decodeFile(newFile.getAbsolutePath(), opts);
String height, width;
if (bm != null)
{
height = Integer.toString(bm.getHeight());
width = Integer.toString(bm.getWidth());
}
else
{
height = Integer.toString(opts.outHeight);
width = Integer.toString(opts.outWidth);
}
bm = null;
builder = new Uri.Builder();
fileUri = builder.scheme("file").appendEncodedPath("/").appendEncodedPath(newFile.getAbsolutePath())
.appendQueryParameter("width", width).appendQueryParameter("height", height).build();
InsertNote.this.mLoggerServiceManager.storeMediaUri(fileUri);
}
else
{
Log.e(TAG, "Failed either rename or copy image: " + file.getAbsolutePath());
}
break;
case MENU_VIDEO:
file = new File(Constants.getSdCardTmpFile(InsertNote.this));
c = Calendar.getInstance();
newName = String.format("Video_%tY%tm%td_%tH%tM%tS.3gp", c, c, c, c, c, c);
newFile = new File(Constants.getSdCardDirectory(InsertNote.this) + newName);
file.getParentFile().mkdirs();
isLocal = file.renameTo(newFile);
if (!isLocal)
{
Log.w(TAG, "Failed rename will try copy video: " + file.getAbsolutePath());
isLocal = copyFile(file, newFile);
}
if (isLocal)
{
builder = new Uri.Builder();
fileUri = builder.scheme("file").appendPath(newFile.getAbsolutePath()).build();
InsertNote.this.mLoggerServiceManager.storeMediaUri(fileUri);
}
else
{
Log.e(TAG, "Failed either rename or copy video: " + file.getAbsolutePath());
}
break;
case MENU_VOICE:
uri = Uri.parse(intent.getDataString());
InsertNote.this.mLoggerServiceManager.storeMediaUri(uri);
break;
default:
Log.e(TAG, "Returned form unknow activity: " + requestCode);
break;
}
}
else
{
Log.w(TAG, "Received unexpected resultcode " + resultCode);
}
setResult(resultCode, new Intent());
finish();
}
};
}
@Override
protected Dialog onCreateDialog(int id)
{
Dialog dialog = null;
LayoutInflater factory = null;
View view = null;
Builder builder = null;
switch (id)
{
case DIALOG_INSERTNOTE:
builder = new AlertDialog.Builder(this);
factory = LayoutInflater.from(this);
view = factory.inflate(R.layout.insertnote, null);
builder.setTitle(R.string.menu_insertnote).setIcon(android.R.drawable.ic_dialog_alert).setNegativeButton(R.string.btn_cancel, mDialogClickListener)
.setView(view);
dialog = builder.create();
name = (Button) view.findViewById(R.id.noteinsert_name);
text = (Button) view.findViewById(R.id.noteinsert_text);
voice = (Button) view.findViewById(R.id.noteinsert_voice);
picture = (Button) view.findViewById(R.id.noteinsert_picture);
video = (Button) view.findViewById(R.id.noteinsert_video);
name.setOnClickListener(mNoteInsertListener);
text.setOnClickListener(mNoteInsertListener);
voice.setOnClickListener(mNoteInsertListener);
picture.setOnClickListener(mNoteInsertListener);
video.setOnClickListener(mNoteInsertListener);
dialog.setOnDismissListener(new OnDismissListener()
{
@Override
public void onDismiss(DialogInterface dialog)
{
if (!paused)
{
finish();
}
}
});
return dialog;
case DIALOG_TEXT:
builder = new AlertDialog.Builder(this);
factory = LayoutInflater.from(this);
view = factory.inflate(R.layout.notetextdialog, null);
mNoteTextView = (EditText) view.findViewById(R.id.notetext);
builder.setTitle(R.string.dialog_notetext_title).setMessage(R.string.dialog_notetext_message).setIcon(android.R.drawable.ic_dialog_map)
.setPositiveButton(R.string.btn_okay, mNoteTextDialogListener).setNegativeButton(R.string.btn_cancel, null).setView(view);
dialog = builder.create();
return dialog;
case DIALOG_NAME:
builder = new AlertDialog.Builder(this);
factory = LayoutInflater.from(this);
view = factory.inflate(R.layout.notenamedialog, null);
mNoteNameView = (EditText) view.findViewById(R.id.notename);
builder.setTitle(R.string.dialog_notename_title).setMessage(R.string.dialog_notename_message).setIcon(android.R.drawable.ic_dialog_map)
.setPositiveButton(R.string.btn_okay, mNoteNameDialogListener).setNegativeButton(R.string.btn_cancel, null).setView(view);
dialog = builder.create();
return dialog;
default:
return super.onCreateDialog(id);
}
}
/*
* (non-Javadoc)
* @see android.app.Activity#onPrepareDialog(int, android.app.Dialog)
*/
@Override
protected void onPrepareDialog(int id, Dialog dialog)
{
switch (id)
{
case DIALOG_INSERTNOTE:
boolean prepared = mLoggerServiceManager.isMediaPrepared() && mLoggerServiceManager.getLoggingState() == Constants.LOGGING;
name = (Button) dialog.findViewById(R.id.noteinsert_name);
text = (Button) dialog.findViewById(R.id.noteinsert_text);
voice = (Button) dialog.findViewById(R.id.noteinsert_voice);
picture = (Button) dialog.findViewById(R.id.noteinsert_picture);
video = (Button) dialog.findViewById(R.id.noteinsert_video);
name.setEnabled(prepared);
text.setEnabled(prepared);
voice.setEnabled(prepared);
picture.setEnabled(prepared);
video.setEnabled(prepared);
break;
default:
break;
}
super.onPrepareDialog(id, dialog);
}
/***
* Collecting additional data
*/
private void addPicture()
{
Intent i = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
File file = new File(Constants.getSdCardTmpFile(this));
// Log.d( TAG, "Picture requested at: " + file );
i.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
i.putExtra(android.provider.MediaStore.EXTRA_VIDEO_QUALITY, 1);
startActivityForResult(i, MENU_PICTURE);
}
/***
* Collecting additional data
*/
private void addVideo()
{
Intent i = new Intent(android.provider.MediaStore.ACTION_VIDEO_CAPTURE);
File file = new File(Constants.getSdCardTmpFile(this));
i.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
i.putExtra(android.provider.MediaStore.EXTRA_VIDEO_QUALITY, 1);
try
{
startActivityForResult(i, MENU_VIDEO);
}
catch (ActivityNotFoundException e)
{
Log.e(TAG, "Unable to start Activity to record video", e);
}
}
private void addVoice()
{
Intent intent = new Intent(android.provider.MediaStore.Audio.Media.RECORD_SOUND_ACTION);
try
{
startActivityForResult(intent, MENU_VOICE);
}
catch (ActivityNotFoundException e)
{
Log.e(TAG, "Unable to start Activity to record audio", e);
}
}
private static boolean copyFile(File fileIn, File fileOut)
{
boolean succes = false;
FileInputStream in = null;
FileOutputStream out = null;
try
{
in = new FileInputStream(fileIn);
out = new FileOutputStream(fileOut);
byte[] buf = new byte[8192];
int i = 0;
while ((i = in.read(buf)) != -1)
{
out.write(buf, 0, i);
}
succes = true;
}
catch (IOException e)
{
Log.e(TAG, "File copy failed", e);
}
finally
{
if (in != null)
{
try
{
in.close();
}
catch (IOException e)
{
Log.w(TAG, "File close after copy failed", e);
}
}
if (in != null)
{
try
{
out.close();
}
catch (IOException e)
{
Log.w(TAG, "File close after copy failed", e);
}
}
}
return succes;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/InsertNote.java | Java | gpl3 | 18,617 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.actions;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.tasks.GpxCreator;
import nl.sogeti.android.gpstracker.actions.tasks.GpxSharing;
import nl.sogeti.android.gpstracker.actions.tasks.JogmapSharing;
import nl.sogeti.android.gpstracker.actions.tasks.KmzCreator;
import nl.sogeti.android.gpstracker.actions.tasks.KmzSharing;
import nl.sogeti.android.gpstracker.actions.tasks.OsmSharing;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.actions.utils.StatisticsCalulator;
import nl.sogeti.android.gpstracker.actions.utils.StatisticsDelegate;
import nl.sogeti.android.gpstracker.breadcrumbs.BreadcrumbsService;
import nl.sogeti.android.gpstracker.breadcrumbs.BreadcrumbsService.LocalBinder;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.UnitsI18n;
import nl.sogeti.android.gpstracker.viewer.map.LoggerMap;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Bundle;
import android.os.IBinder;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.RemoteViews;
import android.widget.Spinner;
import android.widget.Toast;
public class ShareTrack extends Activity implements StatisticsDelegate
{
private static final String TAG = "OGT.ShareTrack";
private static final int EXPORT_TYPE_KMZ = 0;
private static final int EXPORT_TYPE_GPX = 1;
private static final int EXPORT_TYPE_TEXTLINE = 2;
private static final int EXPORT_TARGET_SAVE = 0;
private static final int EXPORT_TARGET_SEND = 1;
private static final int EXPORT_TARGET_JOGRUN = 2;
private static final int EXPORT_TARGET_OSM = 3;
private static final int EXPORT_TARGET_BREADCRUMBS = 4;
private static final int EXPORT_TARGET_TWITTER = 0;
private static final int EXPORT_TARGET_SMS = 1;
private static final int EXPORT_TARGET_TEXT = 2;
private static final int PROGRESS_STEPS = 10;
private static final int DIALOG_ERROR = Menu.FIRST + 28;
private static final int DIALOG_CONNECTBREADCRUMBS = Menu.FIRST + 29;
private static final int DESCRIBE = 312;
private static File sTempBitmap;
private RemoteViews mContentView;
private int barProgress = 0;
private Notification mNotification;
private NotificationManager mNotificationManager;
private EditText mFileNameView;
private EditText mTweetView;
private Spinner mShareTypeSpinner;
private Spinner mShareTargetSpinner;
private Uri mTrackUri;
private BreadcrumbsService mService;
boolean mBound = false;
private String mErrorDialogMessage;
private Throwable mErrorDialogException;
private ImageView mImageView;
private ImageButton mCloseImageView;
private Uri mImageUri;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.sharedialog);
Intent service = new Intent(this, BreadcrumbsService.class);
startService(service);
mTrackUri = getIntent().getData();
mFileNameView = (EditText) findViewById(R.id.fileNameField);
mTweetView = (EditText) findViewById(R.id.tweetField);
mImageView = (ImageView) findViewById(R.id.imageView);
mCloseImageView = (ImageButton) findViewById(R.id.closeImageView);
mShareTypeSpinner = (Spinner) findViewById(R.id.shareTypeSpinner);
ArrayAdapter<CharSequence> shareTypeAdapter = ArrayAdapter.createFromResource(this, R.array.sharetype_choices, android.R.layout.simple_spinner_item);
shareTypeAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
mShareTypeSpinner.setAdapter(shareTypeAdapter);
mShareTargetSpinner = (Spinner) findViewById(R.id.shareTargetSpinner);
mShareTargetSpinner.setOnItemSelectedListener(new OnItemSelectedListener()
{
@Override
public void onItemSelected(AdapterView< ? > arg0, View arg1, int position, long arg3)
{
if (mShareTypeSpinner.getSelectedItemPosition() == EXPORT_TYPE_GPX && position == EXPORT_TARGET_BREADCRUMBS)
{
boolean authorized = mService.isAuthorized();
if (!authorized)
{
showDialog(DIALOG_CONNECTBREADCRUMBS);
}
}
else if (mShareTypeSpinner.getSelectedItemPosition() == EXPORT_TYPE_TEXTLINE && position != EXPORT_TARGET_SMS)
{
readScreenBitmap();
}
else
{
removeScreenBitmap();
}
}
@Override
public void onNothingSelected(AdapterView< ? > arg0)
{ /* NOOP */
}
});
mShareTypeSpinner.setOnItemSelectedListener(new OnItemSelectedListener()
{
@Override
public void onItemSelected(AdapterView< ? > arg0, View arg1, int position, long arg3)
{
adjustTargetToType(position);
}
@Override
public void onNothingSelected(AdapterView< ? > arg0)
{ /* NOOP */
}
});
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
int lastType = prefs.getInt(Constants.EXPORT_TYPE, EXPORT_TYPE_KMZ);
mShareTypeSpinner.setSelection(lastType);
adjustTargetToType(lastType);
mFileNameView.setText(queryForTrackName(getContentResolver(), mTrackUri));
Button okay = (Button) findViewById(R.id.okayshare_button);
okay.setOnClickListener(new View.OnClickListener()
{
@Override
public void onClick(View v)
{
v.setEnabled(false);
share();
}
});
Button cancel = (Button) findViewById(R.id.cancelshare_button);
cancel.setOnClickListener(new View.OnClickListener()
{
@Override
public void onClick(View v)
{
v.setEnabled(false);
ShareTrack.this.finish();
}
});
}
@Override
protected void onStart()
{
super.onStart();
Intent intent = new Intent(this, BreadcrumbsService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}
@Override
protected void onResume()
{
super.onResume();
// Upgrade from stored OSM username/password to OAuth authorization
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
if (prefs.contains(Constants.OSM_USERNAME) || prefs.contains(Constants.OSM_PASSWORD))
{
Editor editor = prefs.edit();
editor.remove(Constants.OSM_USERNAME);
editor.remove(Constants.OSM_PASSWORD);
editor.commit();
}
findViewById(R.id.okayshare_button).setEnabled(true);
findViewById(R.id.cancelshare_button).setEnabled(true);
}
@Override
protected void onStop()
{
if (mBound)
{
unbindService(mConnection);
mBound = false;
mService = null;
}
super.onStop();
}
@Override
protected void onDestroy()
{
if (isFinishing())
{
Intent service = new Intent(this, BreadcrumbsService.class);
stopService(service);
}
super.onDestroy();
}
/**
* @see android.app.Activity#onCreateDialog(int)
*/
@Override
protected Dialog onCreateDialog(int id)
{
Dialog dialog = null;
Builder builder = null;
switch (id)
{
case DIALOG_ERROR:
builder = new AlertDialog.Builder(this);
String exceptionMessage = mErrorDialogException == null ? "" : " (" + mErrorDialogException.getMessage() + ") ";
builder.setIcon(android.R.drawable.ic_dialog_alert).setTitle(android.R.string.dialog_alert_title).setMessage(mErrorDialogMessage + exceptionMessage)
.setNeutralButton(android.R.string.cancel, null);
dialog = builder.create();
return dialog;
case DIALOG_CONNECTBREADCRUMBS:
builder = new AlertDialog.Builder(this);
builder.setTitle(R.string.dialog_breadcrumbsconnect).setMessage(R.string.dialog_breadcrumbsconnect_message).setIcon(android.R.drawable.ic_dialog_alert)
.setPositiveButton(R.string.btn_okay, mBreadcrumbsDialogListener).setNegativeButton(R.string.btn_cancel, null);
dialog = builder.create();
return dialog;
default:
return super.onCreateDialog(id);
}
}
/**
* @see android.app.Activity#onPrepareDialog(int, android.app.Dialog)
*/
@Override
protected void onPrepareDialog(int id, Dialog dialog)
{
super.onPrepareDialog(id, dialog);
AlertDialog alert;
switch (id)
{
case DIALOG_ERROR:
alert = (AlertDialog) dialog;
String exceptionMessage = mErrorDialogException == null ? "" : " (" + mErrorDialogException.getMessage() + ") ";
alert.setMessage(mErrorDialogMessage + exceptionMessage);
break;
}
}
private void setGpxExportTargets()
{
ArrayAdapter<CharSequence> shareTargetAdapter = ArrayAdapter.createFromResource(this, R.array.sharegpxtarget_choices, android.R.layout.simple_spinner_item);
shareTargetAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
mShareTargetSpinner.setAdapter(shareTargetAdapter);
int lastTarget = PreferenceManager.getDefaultSharedPreferences(this).getInt(Constants.EXPORT_GPXTARGET, EXPORT_TARGET_SEND);
mShareTargetSpinner.setSelection(lastTarget);
removeScreenBitmap();
}
private void setKmzExportTargets()
{
ArrayAdapter<CharSequence> shareTargetAdapter = ArrayAdapter.createFromResource(this, R.array.sharekmztarget_choices, android.R.layout.simple_spinner_item);
shareTargetAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
mShareTargetSpinner.setAdapter(shareTargetAdapter);
int lastTarget = PreferenceManager.getDefaultSharedPreferences(this).getInt(Constants.EXPORT_KMZTARGET, EXPORT_TARGET_SEND);
mShareTargetSpinner.setSelection(lastTarget);
removeScreenBitmap();
}
private void setTextLineExportTargets()
{
ArrayAdapter<CharSequence> shareTargetAdapter = ArrayAdapter.createFromResource(this, R.array.sharetexttarget_choices, android.R.layout.simple_spinner_item);
shareTargetAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
mShareTargetSpinner.setAdapter(shareTargetAdapter);
int lastTarget = PreferenceManager.getDefaultSharedPreferences(this).getInt(Constants.EXPORT_TXTTARGET, EXPORT_TARGET_TWITTER);
mShareTargetSpinner.setSelection(lastTarget);
}
private void share()
{
String chosenFileName = mFileNameView.getText().toString();
String textLine = mTweetView.getText().toString();
int type = (int) mShareTypeSpinner.getSelectedItemId();
int target = (int) mShareTargetSpinner.getSelectedItemId();
Editor editor = PreferenceManager.getDefaultSharedPreferences(this).edit();
editor.putInt(Constants.EXPORT_TYPE, type);
switch (type)
{
case EXPORT_TYPE_KMZ:
editor.putInt(Constants.EXPORT_KMZTARGET, target);
editor.commit();
exportKmz(chosenFileName, target);
break;
case EXPORT_TYPE_GPX:
editor.putInt(Constants.EXPORT_GPXTARGET, target);
editor.commit();
exportGpx(chosenFileName, target);
break;
case EXPORT_TYPE_TEXTLINE:
editor.putInt(Constants.EXPORT_TXTTARGET, target);
editor.commit();
exportTextLine(textLine, target);
break;
default:
Log.e(TAG, "Failed to determine sharing type" + type);
break;
}
}
protected void exportKmz(String chosenFileName, int target)
{
switch (target)
{
case EXPORT_TARGET_SEND:
new KmzSharing(this, mTrackUri, chosenFileName, new ShareProgressListener(chosenFileName)).execute();
break;
case EXPORT_TARGET_SAVE:
new KmzCreator(this, mTrackUri, chosenFileName, new ShareProgressListener(chosenFileName)).execute();
break;
default:
Log.e(TAG, "Unable to determine target for sharing KMZ " + target);
break;
}
ShareTrack.this.finish();
}
protected void exportGpx(String chosenFileName, int target)
{
switch (target)
{
case EXPORT_TARGET_SAVE:
new GpxCreator(this, mTrackUri, chosenFileName, true, new ShareProgressListener(chosenFileName)).execute();
ShareTrack.this.finish();
break;
case EXPORT_TARGET_SEND:
new GpxSharing(this, mTrackUri, chosenFileName, true, new ShareProgressListener(chosenFileName)).execute();
ShareTrack.this.finish();
break;
case EXPORT_TARGET_JOGRUN:
new JogmapSharing(this, mTrackUri, chosenFileName, false, new ShareProgressListener(chosenFileName)).execute();
ShareTrack.this.finish();
break;
case EXPORT_TARGET_OSM:
new OsmSharing(this, mTrackUri, false, new ShareProgressListener(OsmSharing.OSM_FILENAME)).execute();
ShareTrack.this.finish();
break;
case EXPORT_TARGET_BREADCRUMBS:
sendToBreadcrumbs(mTrackUri, chosenFileName);
break;
default:
Log.e(TAG, "Unable to determine target for sharing GPX " + target);
break;
}
}
protected void exportTextLine(String message, int target)
{
String subject = "Open GPS Tracker";
switch (target)
{
case EXPORT_TARGET_TWITTER:
sendTweet(message);
break;
case EXPORT_TARGET_SMS:
sendSMS(message);
ShareTrack.this.finish();
break;
case EXPORT_TARGET_TEXT:
sentGenericText(subject, message);
ShareTrack.this.finish();
break;
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data)
{
if (resultCode != RESULT_CANCELED)
{
String name;
switch (requestCode)
{
case DESCRIBE:
Uri trackUri = data.getData();
if (data.getExtras() != null && data.getExtras().containsKey(Constants.NAME))
{
name = data.getExtras().getString(Constants.NAME);
}
else
{
name = "shareToGobreadcrumbs";
}
mService.startUploadTask(this, new ShareProgressListener(name), trackUri, name);
finish();
break;
default:
super.onActivityResult(requestCode, resultCode, data);
break;
}
}
}
private void sendTweet(String tweet)
{
final Intent intent = findTwitterClient();
intent.putExtra(Intent.EXTRA_TEXT, tweet);
if (mImageUri != null)
{
intent.putExtra(Intent.EXTRA_STREAM, mImageUri);
}
startActivity(intent);
ShareTrack.this.finish();
}
private void sendSMS(String msg)
{
final Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setType("vnd.android-dir/mms-sms");
intent.putExtra("sms_body", msg);
startActivity(intent);
}
private void sentGenericText(String subject, String msg)
{
final Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("text/plain");
intent.putExtra(Intent.EXTRA_SUBJECT, subject);
intent.putExtra(Intent.EXTRA_TEXT, msg);
if (mImageUri != null)
{
intent.putExtra(Intent.EXTRA_STREAM, mImageUri);
}
startActivity(intent);
}
private void sendToBreadcrumbs(Uri mTrackUri, String chosenFileName)
{
// Start a description of the track
Intent namingIntent = new Intent(this, DescribeTrack.class);
namingIntent.setData(mTrackUri);
namingIntent.putExtra(Constants.NAME, chosenFileName);
startActivityForResult(namingIntent, DESCRIBE);
}
private Intent findTwitterClient()
{
final String[] twitterApps = {
// package // name
"com.twitter.android", // official
"com.twidroid", // twidroyd
"com.handmark.tweetcaster", // Tweecaster
"com.thedeck.android" // TweetDeck
};
Intent tweetIntent = new Intent(Intent.ACTION_SEND);
tweetIntent.setType("text/plain");
final PackageManager packageManager = getPackageManager();
List<ResolveInfo> list = packageManager.queryIntentActivities(tweetIntent, PackageManager.MATCH_DEFAULT_ONLY);
for (int i = 0; i < twitterApps.length; i++)
{
for (ResolveInfo resolveInfo : list)
{
String p = resolveInfo.activityInfo.packageName;
if (p != null && p.startsWith(twitterApps[i]))
{
tweetIntent.setPackage(p);
}
}
}
return tweetIntent;
}
private void createTweetText()
{
StatisticsCalulator calculator = new StatisticsCalulator(this, new UnitsI18n(this), this);
findViewById(R.id.tweet_progress).setVisibility(View.VISIBLE);
calculator.execute(mTrackUri);
}
@Override
public void finishedCalculations(StatisticsCalulator calculated)
{
String name = queryForTrackName(getContentResolver(), mTrackUri);
String distString = calculated.getDistanceText();
String avgSpeed = calculated.getAvgSpeedText();
String duration = calculated.getDurationText();
String tweetText = String.format(getString(R.string.tweettext, name, distString, avgSpeed, duration));
if (mTweetView.getText().toString().equals(""))
{
mTweetView.setText(tweetText);
}
findViewById(R.id.tweet_progress).setVisibility(View.GONE);
}
private void adjustTargetToType(int position)
{
switch (position)
{
case EXPORT_TYPE_KMZ:
setKmzExportTargets();
mFileNameView.setVisibility(View.VISIBLE);
mTweetView.setVisibility(View.GONE);
break;
case EXPORT_TYPE_GPX:
setGpxExportTargets();
mFileNameView.setVisibility(View.VISIBLE);
mTweetView.setVisibility(View.GONE);
break;
case EXPORT_TYPE_TEXTLINE:
setTextLineExportTargets();
mFileNameView.setVisibility(View.GONE);
mTweetView.setVisibility(View.VISIBLE);
createTweetText();
break;
default:
break;
}
}
public static void sendFile(Context context, Uri fileUri, String fileContentType, String body)
{
Intent sendActionIntent = new Intent(Intent.ACTION_SEND);
sendActionIntent.putExtra(Intent.EXTRA_SUBJECT, context.getString(R.string.email_subject));
sendActionIntent.putExtra(Intent.EXTRA_TEXT, body);
sendActionIntent.putExtra(Intent.EXTRA_STREAM, fileUri);
sendActionIntent.setType(fileContentType);
context.startActivity(Intent.createChooser(sendActionIntent, context.getString(R.string.sender_chooser)));
}
public static String queryForTrackName(ContentResolver resolver, Uri trackUri)
{
Cursor trackCursor = null;
String name = null;
try
{
trackCursor = resolver.query(trackUri, new String[] { Tracks.NAME }, null, null, null);
if (trackCursor.moveToFirst())
{
name = trackCursor.getString(0);
}
}
finally
{
if (trackCursor != null)
{
trackCursor.close();
}
}
return name;
}
public static Uri storeScreenBitmap(Bitmap bm)
{
Uri fileUri = null;
FileOutputStream stream = null;
try
{
clearScreenBitmap();
sTempBitmap = File.createTempFile("shareimage", ".png");
fileUri = Uri.fromFile(sTempBitmap);
stream = new FileOutputStream(sTempBitmap);
bm.compress(CompressFormat.PNG, 100, stream);
}
catch (IOException e)
{
Log.e(TAG, "Bitmap extra storing failed", e);
}
finally
{
try
{
if (stream != null)
{
stream.close();
}
}
catch (IOException e)
{
Log.e(TAG, "Bitmap extra close failed", e);
}
}
return fileUri;
}
public static void clearScreenBitmap()
{
if (sTempBitmap != null && sTempBitmap.exists())
{
sTempBitmap.delete();
sTempBitmap = null;
}
}
private void readScreenBitmap()
{
mImageView.setVisibility(View.GONE);
mCloseImageView.setVisibility(View.GONE);
if (getIntent().getExtras() != null && getIntent().hasExtra(Intent.EXTRA_STREAM))
{
mImageUri = getIntent().getExtras().getParcelable(Intent.EXTRA_STREAM);
if (mImageUri != null)
{
InputStream is = null;
try
{
is = getContentResolver().openInputStream(mImageUri);
mImageView.setImageBitmap(BitmapFactory.decodeStream(is));
mImageView.setVisibility(View.VISIBLE);
mCloseImageView.setVisibility(View.VISIBLE);
mCloseImageView.setOnClickListener(new View.OnClickListener()
{
@Override
public void onClick(View v)
{
removeScreenBitmap();
}
});
}
catch (FileNotFoundException e)
{
Log.e(TAG, "Failed reading image from file", e);
}
finally
{
if (is != null)
{
try
{
is.close();
}
catch (IOException e)
{
Log.e(TAG, "Failed close image from file", e);
}
}
}
}
}
}
private void removeScreenBitmap()
{
mImageView.setVisibility(View.GONE);
mCloseImageView.setVisibility(View.GONE);
mImageUri = null;
}
private ServiceConnection mConnection = new ServiceConnection()
{
@Override
public void onServiceConnected(ComponentName className, IBinder service)
{
// We've bound to LocalService, cast the IBinder and get LocalService instance
LocalBinder binder = (LocalBinder) service;
mService = binder.getService();
mBound = true;
}
@Override
public void onServiceDisconnected(ComponentName arg0)
{
mBound = false;
mService = null;
}
};
private OnClickListener mBreadcrumbsDialogListener = new OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
mService.collectBreadcrumbsOauthToken();
}
};
public class ShareProgressListener implements ProgressListener
{
private String mFileName;
private int mProgress;
public ShareProgressListener(String sharename)
{
mFileName = sharename;
}
public void startNotification()
{
String ns = Context.NOTIFICATION_SERVICE;
mNotificationManager = (NotificationManager) ShareTrack.this.getSystemService(ns);
int icon = android.R.drawable.ic_menu_save;
CharSequence tickerText = getString(R.string.ticker_saving) + "\"" + mFileName + "\"";
mNotification = new Notification();
PendingIntent contentIntent = PendingIntent.getActivity(ShareTrack.this, 0, new Intent(ShareTrack.this, LoggerMap.class).setFlags(Intent.FLAG_ACTIVITY_NEW_TASK),
PendingIntent.FLAG_UPDATE_CURRENT);
mNotification.contentIntent = contentIntent;
mNotification.tickerText = tickerText;
mNotification.icon = icon;
mNotification.flags |= Notification.FLAG_ONGOING_EVENT;
mContentView = new RemoteViews(getPackageName(), R.layout.savenotificationprogress);
mContentView.setImageViewResource(R.id.icon, icon);
mContentView.setTextViewText(R.id.progresstext, tickerText);
mNotification.contentView = mContentView;
}
private void updateNotification()
{
// Log.d( "TAG", "Progress " + progress + " of " + goal );
if (mProgress > 0 && mProgress < Window.PROGRESS_END)
{
if ((mProgress * PROGRESS_STEPS) / Window.PROGRESS_END != barProgress)
{
barProgress = (mProgress * PROGRESS_STEPS) / Window.PROGRESS_END;
mContentView.setProgressBar(R.id.progress, Window.PROGRESS_END, mProgress, false);
mNotificationManager.notify(R.layout.savenotificationprogress, mNotification);
}
}
else if (mProgress == 0)
{
mContentView.setProgressBar(R.id.progress, Window.PROGRESS_END, mProgress, true);
mNotificationManager.notify(R.layout.savenotificationprogress, mNotification);
}
else if (mProgress >= Window.PROGRESS_END)
{
mContentView.setProgressBar(R.id.progress, Window.PROGRESS_END, mProgress, false);
mNotificationManager.notify(R.layout.savenotificationprogress, mNotification);
}
}
public void endNotification(Uri file)
{
mNotificationManager.cancel(R.layout.savenotificationprogress);
}
@Override
public void setIndeterminate(boolean indeterminate)
{
Log.w(TAG, "Unsupported indeterminate progress display");
}
@Override
public void started()
{
startNotification();
}
@Override
public void setProgress(int value)
{
mProgress = value;
updateNotification();
}
@Override
public void finished(Uri result)
{
endNotification(result);
}
@Override
public void showError(String task, String errorDialogMessage, Exception errorDialogException)
{
endNotification(null);
mErrorDialogMessage = errorDialogMessage;
mErrorDialogException = errorDialogException;
if (!isFinishing())
{
showDialog(DIALOG_ERROR);
}
else
{
Toast toast = Toast.makeText(ShareTrack.this, errorDialogMessage, Toast.LENGTH_LONG);
toast.show();
}
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/actions/ShareTrack.java | Java | gpl3 | 30,165 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.logger;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;
import java.util.concurrent.Semaphore;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.db.GPStracking.Media;
import nl.sogeti.android.gpstracker.db.GPStracking.MetaData;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.streaming.StreamUtils;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.viewer.map.CommonLoggerMap;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.database.Cursor;
import android.location.GpsSatellite;
import android.location.GpsStatus;
import android.location.GpsStatus.Listener;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.location.LocationProvider;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.RingtoneManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.PowerManager;
import android.os.RemoteException;
import android.preference.PreferenceManager;
import android.util.Log;
import android.widget.Toast;
/**
* A system service as controlling the background logging of gps locations.
*
* @version $Id$
* @author rene (c) Jan 22, 2009, Sogeti B.V.
*/
public class GPSLoggerService extends Service implements LocationListener
{
private static final float FINE_DISTANCE = 5F;
private static final long FINE_INTERVAL = 1000l;
private static final float FINE_ACCURACY = 20f;
private static final float NORMAL_DISTANCE = 10F;
private static final long NORMAL_INTERVAL = 15000l;
private static final float NORMAL_ACCURACY = 30f;
private static final float COARSE_DISTANCE = 25F;
private static final long COARSE_INTERVAL = 30000l;
private static final float COARSE_ACCURACY = 75f;
private static final float GLOBAL_DISTANCE = 500F;
private static final long GLOBAL_INTERVAL = 300000l;
private static final float GLOBAL_ACCURACY = 1000f;
/**
* <code>MAX_REASONABLE_SPEED</code> is about 324 kilometer per hour or 201
* mile per hour.
*/
private static final int MAX_REASONABLE_SPEED = 90;
/**
* <code>MAX_REASONABLE_ALTITUDECHANGE</code> between the last few waypoints
* and a new one the difference should be less then 200 meter.
*/
private static final int MAX_REASONABLE_ALTITUDECHANGE = 200;
private static final Boolean DEBUG = false;
private static final boolean VERBOSE = false;
private static final String TAG = "OGT.GPSLoggerService";
private static final String SERVICESTATE_DISTANCE = "SERVICESTATE_DISTANCE";
private static final String SERVICESTATE_STATE = "SERVICESTATE_STATE";
private static final String SERVICESTATE_PRECISION = "SERVICESTATE_PRECISION";
private static final String SERVICESTATE_SEGMENTID = "SERVICESTATE_SEGMENTID";
private static final String SERVICESTATE_TRACKID = "SERVICESTATE_TRACKID";
private static final int ADDGPSSTATUSLISTENER = 0;
private static final int REQUEST_FINEGPS_LOCATIONUPDATES = 1;
private static final int REQUEST_NORMALGPS_LOCATIONUPDATES = 2;
private static final int REQUEST_COARSEGPS_LOCATIONUPDATES = 3;
private static final int REQUEST_GLOBALNETWORK_LOCATIONUPDATES = 4;
private static final int REQUEST_CUSTOMGPS_LOCATIONUPDATES = 5;
private static final int STOPLOOPER = 6;
private static final int GPSPROBLEM = 7;
private static final int LOGGING_UNAVAILABLE = R.string.service_connectiondisabled;
/**
* DUP from android.app.Service.START_STICKY
*/
private static final int START_STICKY = 1;
public static final String COMMAND = "nl.sogeti.android.gpstracker.extra.COMMAND";
public static final int EXTRA_COMMAND_START = 0;
public static final int EXTRA_COMMAND_PAUSE = 1;
public static final int EXTRA_COMMAND_RESUME = 2;
public static final int EXTRA_COMMAND_STOP = 3;
private LocationManager mLocationManager;
private NotificationManager mNoticationManager;
private PowerManager.WakeLock mWakeLock;
private Handler mHandler;
/**
* If speeds should be checked to sane values
*/
private boolean mSpeedSanityCheck;
/**
* If broadcasts of location about should be sent to stream location
*/
private boolean mStreamBroadcast;
private long mTrackId = -1;
private long mSegmentId = -1;
private long mWaypointId = -1;
private int mPrecision;
private int mLoggingState = Constants.STOPPED;
private boolean mStartNextSegment;
private String mSources;
private Location mPreviousLocation;
private float mDistance;
private Notification mNotification;
private Vector<Location> mWeakLocations;
private Queue<Double> mAltitudes;
/**
* <code>mAcceptableAccuracy</code> indicates the maximum acceptable accuracy
* of a waypoint in meters.
*/
private float mMaxAcceptableAccuracy = 20;
private int mSatellites = 0;
private boolean mShowingGpsDisabled;
/**
* Should the GPS Status monitor update the notification bar
*/
private boolean mStatusMonitor;
/**
* Time thread to runs tasks that check whether the GPS listener has received
* enough to consider the GPS system alive.
*/
private Timer mHeartbeatTimer;
/**
* Listens to changes in preference to precision and sanity checks
*/
private OnSharedPreferenceChangeListener mSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener()
{
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
{
if (key.equals(Constants.PRECISION) || key.equals(Constants.LOGGING_DISTANCE) || key.equals(Constants.LOGGING_INTERVAL))
{
sendRequestLocationUpdatesMessage();
crashProtectState();
updateNotification();
broadCastLoggingState();
}
else if (key.equals(Constants.SPEEDSANITYCHECK))
{
mSpeedSanityCheck = sharedPreferences.getBoolean(Constants.SPEEDSANITYCHECK, true);
}
else if (key.equals(Constants.STATUS_MONITOR))
{
mLocationManager.removeGpsStatusListener(mStatusListener);
sendRequestStatusUpdateMessage();
updateNotification();
}
else if(key.equals(Constants.BROADCAST_STREAM) || key.equals("VOICEOVER_ENABLED") || key.equals("CUSTOMUPLOAD_ENABLED") )
{
if (key.equals(Constants.BROADCAST_STREAM))
{
mStreamBroadcast = sharedPreferences.getBoolean(Constants.BROADCAST_STREAM, false);
}
StreamUtils.shutdownStreams(GPSLoggerService.this);
if( !mStreamBroadcast )
{
StreamUtils.initStreams(GPSLoggerService.this);
}
}
}
};
@Override
public void onLocationChanged(Location location)
{
if (VERBOSE)
{
Log.v(TAG, "onLocationChanged( Location " + location + " )");
}
;
// Might be claiming GPS disabled but when we were paused this changed and this location proves so
if (mShowingGpsDisabled)
{
notifyOnEnabledProviderNotification(R.string.service_gpsenabled);
}
Location filteredLocation = locationFilter(location);
if (filteredLocation != null)
{
if (mStartNextSegment)
{
mStartNextSegment = false;
// Obey the start segment if the previous location is unknown or far away
if (mPreviousLocation == null || filteredLocation.distanceTo(mPreviousLocation) > 4 * mMaxAcceptableAccuracy)
{
startNewSegment();
}
}
else if( mPreviousLocation != null )
{
mDistance += mPreviousLocation.distanceTo(filteredLocation);
}
storeLocation(filteredLocation);
broadcastLocation(filteredLocation);
mPreviousLocation = location;
}
}
@Override
public void onProviderDisabled(String provider)
{
if (DEBUG)
{
Log.d(TAG, "onProviderDisabled( String " + provider + " )");
}
;
if (mPrecision != Constants.LOGGING_GLOBAL && provider.equals(LocationManager.GPS_PROVIDER))
{
notifyOnDisabledProvider(R.string.service_gpsdisabled);
}
else if (mPrecision == Constants.LOGGING_GLOBAL && provider.equals(LocationManager.NETWORK_PROVIDER))
{
notifyOnDisabledProvider(R.string.service_datadisabled);
}
}
@Override
public void onProviderEnabled(String provider)
{
if (DEBUG)
{
Log.d(TAG, "onProviderEnabled( String " + provider + " )");
}
;
if (mPrecision != Constants.LOGGING_GLOBAL && provider.equals(LocationManager.GPS_PROVIDER))
{
notifyOnEnabledProviderNotification(R.string.service_gpsenabled);
mStartNextSegment = true;
}
else if (mPrecision == Constants.LOGGING_GLOBAL && provider.equals(LocationManager.NETWORK_PROVIDER))
{
notifyOnEnabledProviderNotification(R.string.service_dataenabled);
}
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras)
{
if (DEBUG)
{
Log.d(TAG, "onStatusChanged( String " + provider + ", int " + status + ", Bundle " + extras + " )");
}
;
if (status == LocationProvider.OUT_OF_SERVICE)
{
Log.e(TAG, String.format("Provider %s changed to status %d", provider, status));
}
}
/**
* Listens to GPS status changes
*/
private Listener mStatusListener = new GpsStatus.Listener()
{
@Override
public synchronized void onGpsStatusChanged(int event)
{
switch (event)
{
case GpsStatus.GPS_EVENT_SATELLITE_STATUS:
if (mStatusMonitor)
{
GpsStatus status = mLocationManager.getGpsStatus(null);
mSatellites = 0;
Iterable<GpsSatellite> list = status.getSatellites();
for (GpsSatellite satellite : list)
{
if (satellite.usedInFix())
{
mSatellites++;
}
}
updateNotification();
}
break;
case GpsStatus.GPS_EVENT_STOPPED:
break;
case GpsStatus.GPS_EVENT_STARTED:
break;
default:
break;
}
}
};
private IBinder mBinder = new IGPSLoggerServiceRemote.Stub()
{
@Override
public int loggingState() throws RemoteException
{
return mLoggingState;
}
@Override
public long startLogging() throws RemoteException
{
GPSLoggerService.this.startLogging();
return mTrackId;
}
@Override
public void pauseLogging() throws RemoteException
{
GPSLoggerService.this.pauseLogging();
}
@Override
public long resumeLogging() throws RemoteException
{
GPSLoggerService.this.resumeLogging();
return mSegmentId;
}
@Override
public void stopLogging() throws RemoteException
{
GPSLoggerService.this.stopLogging();
}
@Override
public Uri storeMediaUri(Uri mediaUri) throws RemoteException
{
GPSLoggerService.this.storeMediaUri(mediaUri);
return null;
}
@Override
public boolean isMediaPrepared() throws RemoteException
{
return GPSLoggerService.this.isMediaPrepared();
}
@Override
public void storeDerivedDataSource(String sourceName) throws RemoteException
{
GPSLoggerService.this.storeDerivedDataSource(sourceName);
}
@Override
public Location getLastWaypoint() throws RemoteException
{
return GPSLoggerService.this.getLastWaypoint();
}
@Override
public float getTrackedDistance() throws RemoteException
{
return GPSLoggerService.this.getTrackedDistance();
}
};
/**
* Task that will be run periodically during active logging to verify that
* the logging really happens and that the GPS hasn't silently stopped.
*/
private TimerTask mHeartbeat = null;
/**
* Task to determine if the GPS is alive
*/
class Heartbeat extends TimerTask
{
private String mProvider;
public Heartbeat(String provider)
{
mProvider = provider;
}
@Override
public void run()
{
if (isLogging())
{
// Collect the last location from the last logged location or a more recent from the last weak location
Location checkLocation = mPreviousLocation;
synchronized (mWeakLocations)
{
if (!mWeakLocations.isEmpty())
{
if (checkLocation == null)
{
checkLocation = mWeakLocations.lastElement();
}
else
{
Location weakLocation = mWeakLocations.lastElement();
checkLocation = weakLocation.getTime() > checkLocation.getTime() ? weakLocation : checkLocation;
}
}
}
// Is the last known GPS location something nearby we are not told?
Location managerLocation = mLocationManager.getLastKnownLocation(mProvider);
if (managerLocation != null && checkLocation != null)
{
if (checkLocation.distanceTo(managerLocation) < 2 * mMaxAcceptableAccuracy)
{
checkLocation = managerLocation.getTime() > checkLocation.getTime() ? managerLocation : checkLocation;
}
}
if (checkLocation == null || checkLocation.getTime() + mCheckPeriod < new Date().getTime())
{
Log.w(TAG, "GPS system failed to produce a location during logging: " + checkLocation);
mLoggingState = Constants.PAUSED;
resumeLogging();
if (mStatusMonitor)
{
soundGpsSignalAlarm();
}
}
}
}
};
/**
* Number of milliseconds that a functioning GPS system needs to provide a
* location. Calculated to be either 120 seconds or 4 times the requested
* period, whichever is larger.
*/
private long mCheckPeriod;
private float mBroadcastDistance;
private long mLastTimeBroadcast;
private class GPSLoggerServiceThread extends Thread
{
public Semaphore ready = new Semaphore(0);
GPSLoggerServiceThread()
{
this.setName("GPSLoggerServiceThread");
}
@Override
public void run()
{
Looper.prepare();
mHandler = new Handler()
{
@Override
public void handleMessage(Message msg)
{
_handleMessage(msg);
}
};
ready.release(); // Signal the looper and handler are created
Looper.loop();
}
}
/**
* Called by the system when the service is first created. Do not call this
* method directly. Be sure to call super.onCreate().
*/
@Override
public void onCreate()
{
super.onCreate();
if (DEBUG)
{
Log.d(TAG, "onCreate()");
}
;
GPSLoggerServiceThread looper = new GPSLoggerServiceThread();
looper.start();
try
{
looper.ready.acquire();
}
catch (InterruptedException e)
{
Log.e(TAG, "Interrupted during wait for the GPSLoggerServiceThread to start, prepare for trouble!", e);
}
mHeartbeatTimer = new Timer("heartbeat", true);
mWeakLocations = new Vector<Location>(3);
mAltitudes = new LinkedList<Double>();
mLoggingState = Constants.STOPPED;
mStartNextSegment = false;
mLocationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
mNoticationManager = (NotificationManager) this.getSystemService(Context.NOTIFICATION_SERVICE);
stopNotification();
SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
mSpeedSanityCheck = sharedPreferences.getBoolean(Constants.SPEEDSANITYCHECK, true);
mStreamBroadcast = sharedPreferences.getBoolean(Constants.BROADCAST_STREAM, false);
boolean startImmidiatly = PreferenceManager.getDefaultSharedPreferences(this).getBoolean(Constants.LOGATSTARTUP, false);
crashRestoreState();
if (startImmidiatly && mLoggingState == Constants.STOPPED)
{
startLogging();
ContentValues values = new ContentValues();
values.put(Tracks.NAME, "Recorded at startup");
getContentResolver().update(ContentUris.withAppendedId(Tracks.CONTENT_URI, mTrackId), values, null, null);
}
else
{
broadCastLoggingState();
}
}
/**
* This is the old onStart method that will be called on the pre-2.0
*
* @see android.app.Service#onStart(android.content.Intent, int) platform. On
* 2.0 or later we override onStartCommand() so this method will not be
* called.
*/
@Override
public void onStart(Intent intent, int startId)
{
handleCommand(intent);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId)
{
handleCommand(intent);
// We want this service to continue running until it is explicitly
// stopped, so return sticky.
return START_STICKY;
}
private void handleCommand(Intent intent)
{
if (DEBUG)
{
Log.d(TAG, "handleCommand(Intent " + intent + ")");
}
;
if (intent != null && intent.hasExtra(COMMAND))
{
switch (intent.getIntExtra(COMMAND, -1))
{
case EXTRA_COMMAND_START:
startLogging();
break;
case EXTRA_COMMAND_PAUSE:
pauseLogging();
break;
case EXTRA_COMMAND_RESUME:
resumeLogging();
break;
case EXTRA_COMMAND_STOP:
stopLogging();
break;
default:
break;
}
}
}
/**
* (non-Javadoc)
*
* @see android.app.Service#onDestroy()
*/
@Override
public void onDestroy()
{
if (DEBUG)
{
Log.d(TAG, "onDestroy()");
}
;
super.onDestroy();
if (isLogging())
{
Log.w(TAG, "Destroyin an activly logging service");
}
mHeartbeatTimer.cancel();
mHeartbeatTimer.purge();
if (this.mWakeLock != null)
{
this.mWakeLock.release();
this.mWakeLock = null;
}
PreferenceManager.getDefaultSharedPreferences(this).unregisterOnSharedPreferenceChangeListener(this.mSharedPreferenceChangeListener);
mLocationManager.removeGpsStatusListener(mStatusListener);
stopListening();
mNoticationManager.cancel(R.layout.map_widgets);
Message msg = Message.obtain();
msg.what = STOPLOOPER;
mHandler.sendMessage(msg);
}
private void crashProtectState()
{
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
Editor editor = preferences.edit();
editor.putLong(SERVICESTATE_TRACKID, mTrackId);
editor.putLong(SERVICESTATE_SEGMENTID, mSegmentId);
editor.putInt(SERVICESTATE_PRECISION, mPrecision);
editor.putInt(SERVICESTATE_STATE, mLoggingState);
editor.putFloat(SERVICESTATE_DISTANCE, mDistance);
editor.commit();
if (DEBUG)
{
Log.d(TAG, "crashProtectState()");
}
;
}
private synchronized void crashRestoreState()
{
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
long previousState = preferences.getInt(SERVICESTATE_STATE, Constants.STOPPED);
if (previousState == Constants.LOGGING || previousState == Constants.PAUSED)
{
Log.w(TAG, "Recovering from a crash or kill and restoring state.");
startNotification();
mTrackId = preferences.getLong(SERVICESTATE_TRACKID, -1);
mSegmentId = preferences.getLong(SERVICESTATE_SEGMENTID, -1);
mPrecision = preferences.getInt(SERVICESTATE_PRECISION, -1);
mDistance = preferences.getFloat(SERVICESTATE_DISTANCE, 0F);
if (previousState == Constants.LOGGING)
{
mLoggingState = Constants.PAUSED;
resumeLogging();
}
else if (previousState == Constants.PAUSED)
{
mLoggingState = Constants.LOGGING;
pauseLogging();
}
}
}
/**
* (non-Javadoc)
*
* @see android.app.Service#onBind(android.content.Intent)
*/
@Override
public IBinder onBind(Intent intent)
{
return this.mBinder;
}
/**
* (non-Javadoc)
*
* @see nl.sogeti.android.gpstracker.IGPSLoggerService#getLoggingState()
*/
protected boolean isLogging()
{
return this.mLoggingState == Constants.LOGGING;
}
/**
* Provides the cached last stored waypoint it current logging is active alse
* null.
*
* @return last waypoint location or null
*/
protected Location getLastWaypoint()
{
Location myLastWaypoint = null;
if (isLogging())
{
myLastWaypoint = mPreviousLocation;
}
return myLastWaypoint;
}
public float getTrackedDistance()
{
float distance = 0F;
if (isLogging())
{
distance = mDistance;
}
return distance;
}
protected boolean isMediaPrepared()
{
return !(mTrackId < 0 || mSegmentId < 0 || mWaypointId < 0);
}
/**
* (non-Javadoc)
*
* @see nl.sogeti.android.gpstracker.IGPSLoggerService#startLogging()
*/
public synchronized void startLogging()
{
if (DEBUG)
{
Log.d(TAG, "startLogging()");
}
;
if (this.mLoggingState == Constants.STOPPED)
{
startNewTrack();
sendRequestLocationUpdatesMessage();
sendRequestStatusUpdateMessage();
this.mLoggingState = Constants.LOGGING;
updateWakeLock();
startNotification();
crashProtectState();
broadCastLoggingState();
}
}
public synchronized void pauseLogging()
{
if (DEBUG)
{
Log.d(TAG, "pauseLogging()");
}
;
if (this.mLoggingState == Constants.LOGGING)
{
mLocationManager.removeGpsStatusListener(mStatusListener);
stopListening();
mLoggingState = Constants.PAUSED;
mPreviousLocation = null;
updateWakeLock();
updateNotification();
mSatellites = 0;
updateNotification();
crashProtectState();
broadCastLoggingState();
}
}
public synchronized void resumeLogging()
{
if (DEBUG)
{
Log.d(TAG, "resumeLogging()");
}
;
if (this.mLoggingState == Constants.PAUSED)
{
if (mPrecision != Constants.LOGGING_GLOBAL)
{
mStartNextSegment = true;
}
sendRequestLocationUpdatesMessage();
sendRequestStatusUpdateMessage();
this.mLoggingState = Constants.LOGGING;
updateWakeLock();
updateNotification();
crashProtectState();
broadCastLoggingState();
}
}
/**
* (non-Javadoc)
*
* @see nl.sogeti.android.gpstracker.IGPSLoggerService#stopLogging()
*/
public synchronized void stopLogging()
{
if (DEBUG)
{
Log.d(TAG, "stopLogging()");
}
;
mLoggingState = Constants.STOPPED;
crashProtectState();
updateWakeLock();
PreferenceManager.getDefaultSharedPreferences(this).unregisterOnSharedPreferenceChangeListener(this.mSharedPreferenceChangeListener);
mLocationManager.removeGpsStatusListener(mStatusListener);
stopListening();
stopNotification();
broadCastLoggingState();
}
private void startListening(String provider, long intervaltime, float distance)
{
mLocationManager.removeUpdates(this);
mLocationManager.requestLocationUpdates(provider, intervaltime, distance, this);
mCheckPeriod = Math.max(12 * intervaltime, 120 * 1000);
if (mHeartbeat != null)
{
mHeartbeat.cancel();
mHeartbeat = null;
}
mHeartbeat = new Heartbeat(provider);
mHeartbeatTimer.schedule(mHeartbeat, mCheckPeriod, mCheckPeriod);
}
private void stopListening()
{
if (mHeartbeat != null)
{
mHeartbeat.cancel();
mHeartbeat = null;
}
mLocationManager.removeUpdates(this);
}
/**
* (non-Javadoc)
*
* @see nl.sogeti.android.gpstracker.IGPSLoggerService#storeDerivedDataSource(java.lang.String)
*/
public void storeDerivedDataSource(String sourceName)
{
Uri trackMetaDataUri = Uri.withAppendedPath(Tracks.CONTENT_URI, mTrackId + "/metadata");
if (mTrackId >= 0)
{
if (mSources == null)
{
Cursor metaData = null;
String source = null;
try
{
metaData = this.getContentResolver().query(trackMetaDataUri, new String[] { MetaData.VALUE }, MetaData.KEY + " = ? ",
new String[] { Constants.DATASOURCES_KEY }, null);
if (metaData.moveToFirst())
{
source = metaData.getString(0);
}
}
finally
{
if (metaData != null)
{
metaData.close();
}
}
if (source != null)
{
mSources = source;
}
else
{
mSources = sourceName;
ContentValues args = new ContentValues();
args.put(MetaData.KEY, Constants.DATASOURCES_KEY);
args.put(MetaData.VALUE, mSources);
this.getContentResolver().insert(trackMetaDataUri, args);
}
}
if (!mSources.contains(sourceName))
{
mSources += "," + sourceName;
ContentValues args = new ContentValues();
args.put(MetaData.VALUE, mSources);
this.getContentResolver().update(trackMetaDataUri, args, MetaData.KEY + " = ? ", new String[] { Constants.DATASOURCES_KEY });
}
}
}
private void startNotification()
{
mNoticationManager.cancel(R.layout.map_widgets);
int icon = R.drawable.ic_maps_indicator_current_position;
CharSequence tickerText = getResources().getString(R.string.service_start);
long when = System.currentTimeMillis();
mNotification = new Notification(icon, tickerText, when);
mNotification.flags |= Notification.FLAG_ONGOING_EVENT;
updateNotification();
if (Build.VERSION.SDK_INT >= 5)
{
startForegroundReflected(R.layout.map_widgets, mNotification);
}
else
{
mNoticationManager.notify(R.layout.map_widgets, mNotification);
}
}
private void updateNotification()
{
CharSequence contentTitle = getResources().getString(R.string.app_name);
String precision = getResources().getStringArray(R.array.precision_choices)[mPrecision];
String state = getResources().getStringArray(R.array.state_choices)[mLoggingState - 1];
CharSequence contentText;
switch (mPrecision)
{
case (Constants.LOGGING_GLOBAL):
contentText = getResources().getString(R.string.service_networkstatus, state, precision);
break;
default:
if (mStatusMonitor)
{
contentText = getResources().getString(R.string.service_gpsstatus, state, precision, mSatellites);
}
else
{
contentText = getResources().getString(R.string.service_gpsnostatus, state, precision);
}
break;
}
Intent notificationIntent = new Intent(this, CommonLoggerMap.class);
notificationIntent.setData(ContentUris.withAppendedId(Tracks.CONTENT_URI, mTrackId));
mNotification.contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, Intent.FLAG_ACTIVITY_NEW_TASK);
mNotification.setLatestEventInfo(this, contentTitle, contentText, mNotification.contentIntent);
mNoticationManager.notify(R.layout.map_widgets, mNotification);
}
private void stopNotification()
{
if (Build.VERSION.SDK_INT >= 5)
{
stopForegroundReflected(true);
}
else
{
mNoticationManager.cancel(R.layout.map_widgets);
}
}
private void notifyOnEnabledProviderNotification(int resId)
{
mNoticationManager.cancel(LOGGING_UNAVAILABLE);
mShowingGpsDisabled = false;
CharSequence text = this.getString(resId);
Toast toast = Toast.makeText(this, text, Toast.LENGTH_LONG);
toast.show();
}
private void notifyOnPoorSignal(int resId)
{
int icon = R.drawable.ic_maps_indicator_current_position;
CharSequence tickerText = getResources().getString(resId);
long when = System.currentTimeMillis();
Notification signalNotification = new Notification(icon, tickerText, when);
CharSequence contentTitle = getResources().getString(R.string.app_name);
Intent notificationIntent = new Intent(this, CommonLoggerMap.class);
PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, Intent.FLAG_ACTIVITY_NEW_TASK);
signalNotification.setLatestEventInfo(this, contentTitle, tickerText, contentIntent);
signalNotification.flags |= Notification.FLAG_AUTO_CANCEL;
mNoticationManager.notify(resId, signalNotification);
}
private void notifyOnDisabledProvider(int resId)
{
int icon = R.drawable.ic_maps_indicator_current_position;
CharSequence tickerText = getResources().getString(resId);
long when = System.currentTimeMillis();
Notification gpsNotification = new Notification(icon, tickerText, when);
gpsNotification.flags |= Notification.FLAG_AUTO_CANCEL;
CharSequence contentTitle = getResources().getString(R.string.app_name);
CharSequence contentText = getResources().getString(resId);
Intent notificationIntent = new Intent(this, CommonLoggerMap.class);
notificationIntent.setData(ContentUris.withAppendedId(Tracks.CONTENT_URI, mTrackId));
PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, Intent.FLAG_ACTIVITY_NEW_TASK);
gpsNotification.setLatestEventInfo(this, contentTitle, contentText, contentIntent);
mNoticationManager.notify(LOGGING_UNAVAILABLE, gpsNotification);
mShowingGpsDisabled = true;
}
/**
* Send a system broadcast to notify a change in the logging or precision
*/
private void broadCastLoggingState()
{
Intent broadcast = new Intent(Constants.LOGGING_STATE_CHANGED_ACTION);
broadcast.putExtra(Constants.EXTRA_LOGGING_PRECISION, mPrecision);
broadcast.putExtra(Constants.EXTRA_LOGGING_STATE, mLoggingState);
this.getApplicationContext().sendBroadcast(broadcast);
if( isLogging() )
{
StreamUtils.initStreams(this);
}
else
{
StreamUtils.shutdownStreams(this);
}
}
private void sendRequestStatusUpdateMessage()
{
mStatusMonitor = PreferenceManager.getDefaultSharedPreferences(this).getBoolean(Constants.STATUS_MONITOR, false);
Message msg = Message.obtain();
msg.what = ADDGPSSTATUSLISTENER;
mHandler.sendMessage(msg);
}
private void sendRequestLocationUpdatesMessage()
{
stopListening();
mPrecision = Integer.valueOf(PreferenceManager.getDefaultSharedPreferences(this).getString(Constants.PRECISION, "2")).intValue();
Message msg = Message.obtain();
switch (mPrecision)
{
case (Constants.LOGGING_FINE): // Fine
msg.what = REQUEST_FINEGPS_LOCATIONUPDATES;
mHandler.sendMessage(msg);
break;
case (Constants.LOGGING_NORMAL): // Normal
msg.what = REQUEST_NORMALGPS_LOCATIONUPDATES;
mHandler.sendMessage(msg);
break;
case (Constants.LOGGING_COARSE): // Coarse
msg.what = REQUEST_COARSEGPS_LOCATIONUPDATES;
mHandler.sendMessage(msg);
break;
case (Constants.LOGGING_GLOBAL): // Global
msg.what = REQUEST_GLOBALNETWORK_LOCATIONUPDATES;
mHandler.sendMessage(msg);
break;
case (Constants.LOGGING_CUSTOM): // Global
msg.what = REQUEST_CUSTOMGPS_LOCATIONUPDATES;
mHandler.sendMessage(msg);
break;
default:
Log.e(TAG, "Unknown precision " + mPrecision);
break;
}
}
/**
* Message handler method to do the work off-loaded by mHandler to
* GPSLoggerServiceThread
*
* @param msg
*/
private void _handleMessage(Message msg)
{
if (DEBUG)
{
Log.d(TAG, "_handleMessage( Message " + msg + " )");
}
;
long intervaltime = 0;
float distance = 0;
switch (msg.what)
{
case ADDGPSSTATUSLISTENER:
this.mLocationManager.addGpsStatusListener(mStatusListener);
break;
case REQUEST_FINEGPS_LOCATIONUPDATES:
mMaxAcceptableAccuracy = FINE_ACCURACY;
intervaltime = FINE_INTERVAL;
distance = FINE_DISTANCE;
startListening(LocationManager.GPS_PROVIDER, intervaltime, distance);
break;
case REQUEST_NORMALGPS_LOCATIONUPDATES:
mMaxAcceptableAccuracy = NORMAL_ACCURACY;
intervaltime = NORMAL_INTERVAL;
distance = NORMAL_DISTANCE;
startListening(LocationManager.GPS_PROVIDER, intervaltime, distance);
break;
case REQUEST_COARSEGPS_LOCATIONUPDATES:
mMaxAcceptableAccuracy = COARSE_ACCURACY;
intervaltime = COARSE_INTERVAL;
distance = COARSE_DISTANCE;
startListening(LocationManager.GPS_PROVIDER, intervaltime, distance);
break;
case REQUEST_GLOBALNETWORK_LOCATIONUPDATES:
mMaxAcceptableAccuracy = GLOBAL_ACCURACY;
intervaltime = GLOBAL_INTERVAL;
distance = GLOBAL_DISTANCE;
startListening(LocationManager.NETWORK_PROVIDER, intervaltime, distance);
if (!isNetworkConnected())
{
notifyOnDisabledProvider(R.string.service_connectiondisabled);
}
break;
case REQUEST_CUSTOMGPS_LOCATIONUPDATES:
intervaltime = 60 * 1000 * Long.valueOf(PreferenceManager.getDefaultSharedPreferences(this).getString(Constants.LOGGING_INTERVAL, "15000"));
distance = Float.valueOf(PreferenceManager.getDefaultSharedPreferences(this).getString(Constants.LOGGING_DISTANCE, "10"));
mMaxAcceptableAccuracy = Math.max(10f, Math.min(distance, 50f));
startListening(LocationManager.GPS_PROVIDER, intervaltime, distance);
break;
case STOPLOOPER:
mLocationManager.removeGpsStatusListener(mStatusListener);
stopListening();
Looper.myLooper().quit();
break;
case GPSPROBLEM:
notifyOnPoorSignal(R.string.service_gpsproblem);
break;
}
}
private void updateWakeLock()
{
if (this.mLoggingState == Constants.LOGGING)
{
PreferenceManager.getDefaultSharedPreferences(this).registerOnSharedPreferenceChangeListener(mSharedPreferenceChangeListener);
PowerManager pm = (PowerManager) this.getSystemService(Context.POWER_SERVICE);
if (this.mWakeLock != null)
{
this.mWakeLock.release();
this.mWakeLock = null;
}
this.mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
this.mWakeLock.acquire();
}
else
{
if (this.mWakeLock != null)
{
this.mWakeLock.release();
this.mWakeLock = null;
}
}
}
/**
* Some GPS waypoints received are of to low a quality for tracking use. Here
* we filter those out.
*
* @param proposedLocation
* @return either the (cleaned) original or null when unacceptable
*/
public Location locationFilter(Location proposedLocation)
{
// Do no include log wrong 0.0 lat 0.0 long, skip to next value in while-loop
if (proposedLocation != null && (proposedLocation.getLatitude() == 0.0d || proposedLocation.getLongitude() == 0.0d))
{
Log.w(TAG, "A wrong location was received, 0.0 latitude and 0.0 longitude... ");
proposedLocation = null;
}
// Do not log a waypoint which is more inaccurate then is configured to be acceptable
if (proposedLocation != null && proposedLocation.getAccuracy() > mMaxAcceptableAccuracy)
{
Log.w(TAG, String.format("A weak location was received, lots of inaccuracy... (%f is more then max %f)", proposedLocation.getAccuracy(),
mMaxAcceptableAccuracy));
proposedLocation = addBadLocation(proposedLocation);
}
// Do not log a waypoint which might be on any side of the previous waypoint
if (proposedLocation != null && mPreviousLocation != null && proposedLocation.getAccuracy() > mPreviousLocation.distanceTo(proposedLocation))
{
Log.w(TAG,
String.format("A weak location was received, not quite clear from the previous waypoint... (%f more then max %f)",
proposedLocation.getAccuracy(), mPreviousLocation.distanceTo(proposedLocation)));
proposedLocation = addBadLocation(proposedLocation);
}
// Speed checks, check if the proposed location could be reached from the previous one in sane speed
// Common to jump on network logging and sometimes jumps on Samsung Galaxy S type of devices
if (mSpeedSanityCheck && proposedLocation != null && mPreviousLocation != null)
{
// To avoid near instant teleportation on network location or glitches cause continent hopping
float meters = proposedLocation.distanceTo(mPreviousLocation);
long seconds = (proposedLocation.getTime() - mPreviousLocation.getTime()) / 1000L;
float speed = meters / seconds;
if (speed > MAX_REASONABLE_SPEED)
{
Log.w(TAG, "A strange location was received, a really high speed of " + speed + " m/s, prob wrong...");
proposedLocation = addBadLocation(proposedLocation);
// Might be a messed up Samsung Galaxy S GPS, reset the logging
if (speed > 2 * MAX_REASONABLE_SPEED && mPrecision != Constants.LOGGING_GLOBAL)
{
Log.w(TAG, "A strange location was received on GPS, reset the GPS listeners");
stopListening();
mLocationManager.removeGpsStatusListener(mStatusListener);
mLocationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
sendRequestStatusUpdateMessage();
sendRequestLocationUpdatesMessage();
}
}
}
// Remove speed if not sane
if (mSpeedSanityCheck && proposedLocation != null && proposedLocation.getSpeed() > MAX_REASONABLE_SPEED)
{
Log.w(TAG, "A strange speed, a really high speed, prob wrong...");
proposedLocation.removeSpeed();
}
// Remove altitude if not sane
if (mSpeedSanityCheck && proposedLocation != null && proposedLocation.hasAltitude())
{
if (!addSaneAltitude(proposedLocation.getAltitude()))
{
Log.w(TAG, "A strange altitude, a really big difference, prob wrong...");
proposedLocation.removeAltitude();
}
}
// Older bad locations will not be needed
if (proposedLocation != null)
{
mWeakLocations.clear();
}
return proposedLocation;
}
/**
* Store a bad location, when to many bad locations are stored the the
* storage is cleared and the least bad one is returned
*
* @param location bad location
* @return null when the bad location is stored or the least bad one if the
* storage was full
*/
private Location addBadLocation(Location location)
{
mWeakLocations.add(location);
if (mWeakLocations.size() < 3)
{
location = null;
}
else
{
Location best = mWeakLocations.lastElement();
for (Location whimp : mWeakLocations)
{
if (whimp.hasAccuracy() && best.hasAccuracy() && whimp.getAccuracy() < best.getAccuracy())
{
best = whimp;
}
else
{
if (whimp.hasAccuracy() && !best.hasAccuracy())
{
best = whimp;
}
}
}
synchronized (mWeakLocations)
{
mWeakLocations.clear();
}
location = best;
}
return location;
}
/**
* Builds a bit of knowledge about altitudes to expect and return if the
* added value is deemed sane.
*
* @param altitude
* @return whether the altitude is considered sane
*/
private boolean addSaneAltitude(double altitude)
{
boolean sane = true;
double avg = 0;
int elements = 0;
// Even insane altitude shifts increases alter perception
mAltitudes.add(altitude);
if (mAltitudes.size() > 3)
{
mAltitudes.poll();
}
for (Double alt : mAltitudes)
{
avg += alt;
elements++;
}
avg = avg / elements;
sane = Math.abs(altitude - avg) < MAX_REASONABLE_ALTITUDECHANGE;
return sane;
}
/**
* Trigged by events that start a new track
*/
private void startNewTrack()
{
mDistance = 0;
Uri newTrack = this.getContentResolver().insert(Tracks.CONTENT_URI, new ContentValues(0));
mTrackId = Long.valueOf(newTrack.getLastPathSegment()).longValue();
startNewSegment();
}
/**
* Trigged by events that start a new segment
*/
private void startNewSegment()
{
this.mPreviousLocation = null;
Uri newSegment = this.getContentResolver().insert(Uri.withAppendedPath(Tracks.CONTENT_URI, mTrackId + "/segments"), new ContentValues(0));
mSegmentId = Long.valueOf(newSegment.getLastPathSegment()).longValue();
crashProtectState();
}
protected void storeMediaUri(Uri mediaUri)
{
if (isMediaPrepared())
{
Uri mediaInsertUri = Uri.withAppendedPath(Tracks.CONTENT_URI, mTrackId + "/segments/" + mSegmentId + "/waypoints/" + mWaypointId + "/media");
ContentValues args = new ContentValues();
args.put(Media.URI, mediaUri.toString());
this.getContentResolver().insert(mediaInsertUri, args);
}
else
{
Log.e(TAG, "No logging done under which to store the track");
}
}
/**
* Use the ContentResolver mechanism to store a received location
*
* @param location
*/
public void storeLocation(Location location)
{
if (!isLogging())
{
Log.e(TAG, String.format("Not logging but storing location %s, prepare to fail", location.toString()));
}
ContentValues args = new ContentValues();
args.put(Waypoints.LATITUDE, Double.valueOf(location.getLatitude()));
args.put(Waypoints.LONGITUDE, Double.valueOf(location.getLongitude()));
args.put(Waypoints.SPEED, Float.valueOf(location.getSpeed()));
args.put(Waypoints.TIME, Long.valueOf(System.currentTimeMillis()));
if (location.hasAccuracy())
{
args.put(Waypoints.ACCURACY, Float.valueOf(location.getAccuracy()));
}
if (location.hasAltitude())
{
args.put(Waypoints.ALTITUDE, Double.valueOf(location.getAltitude()));
}
if (location.hasBearing())
{
args.put(Waypoints.BEARING, Float.valueOf(location.getBearing()));
}
Uri waypointInsertUri = Uri.withAppendedPath(Tracks.CONTENT_URI, mTrackId + "/segments/" + mSegmentId + "/waypoints");
Uri inserted = this.getContentResolver().insert(waypointInsertUri, args);
mWaypointId = Long.parseLong(inserted.getLastPathSegment());
}
/**
* Consult broadcast options and execute broadcast if necessary
*
* @param location
*/
public void broadcastLocation(Location location)
{
Intent intent = new Intent(Constants.STREAMBROADCAST);
if (mStreamBroadcast)
{
final long minDistance = (long) PreferenceManager.getDefaultSharedPreferences(this).getFloat("streambroadcast_distance_meter", 5000F);
final long minTime = 60000 * Long.parseLong(PreferenceManager.getDefaultSharedPreferences(this).getString("streambroadcast_time", "1"));
final long nowTime = location.getTime();
if (mPreviousLocation != null)
{
mBroadcastDistance += location.distanceTo(mPreviousLocation);
}
if (mLastTimeBroadcast == 0)
{
mLastTimeBroadcast = nowTime;
}
long passedTime = (nowTime - mLastTimeBroadcast);
intent.putExtra(Constants.EXTRA_DISTANCE, (int) mBroadcastDistance);
intent.putExtra(Constants.EXTRA_TIME, (int) passedTime/60000);
intent.putExtra(Constants.EXTRA_LOCATION, location);
intent.putExtra(Constants.EXTRA_TRACK, ContentUris.withAppendedId(Tracks.CONTENT_URI, mTrackId));
boolean distanceBroadcast = minDistance > 0 && mBroadcastDistance >= minDistance;
boolean timeBroadcast = minTime > 0 && passedTime >= minTime;
if (distanceBroadcast || timeBroadcast)
{
if (distanceBroadcast)
{
mBroadcastDistance = 0;
}
if (timeBroadcast)
{
mLastTimeBroadcast = nowTime;
}
this.sendBroadcast(intent, "android.permission.ACCESS_FINE_LOCATION");
}
}
}
private boolean isNetworkConnected()
{
ConnectivityManager connMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo info = connMgr.getActiveNetworkInfo();
return (info != null && info.isConnected());
}
private void soundGpsSignalAlarm()
{
Uri alert = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_ALARM);
if (alert == null)
{
alert = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
if (alert == null)
{
alert = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE);
}
}
MediaPlayer mMediaPlayer = new MediaPlayer();
try
{
mMediaPlayer.setDataSource(GPSLoggerService.this, alert);
final AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
if (audioManager.getStreamVolume(AudioManager.STREAM_ALARM) != 0)
{
mMediaPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
mMediaPlayer.setLooping(false);
mMediaPlayer.prepare();
mMediaPlayer.start();
}
}
catch (IllegalArgumentException e)
{
Log.e(TAG, "Problem setting data source for mediaplayer", e);
}
catch (SecurityException e)
{
Log.e(TAG, "Problem setting data source for mediaplayer", e);
}
catch (IllegalStateException e)
{
Log.e(TAG, "Problem with mediaplayer", e);
}
catch (IOException e)
{
Log.e(TAG, "Problem with mediaplayer", e);
}
Message msg = Message.obtain();
msg.what = GPSPROBLEM;
mHandler.sendMessage(msg);
}
@SuppressWarnings("rawtypes")
private void startForegroundReflected(int id, Notification notification)
{
Method mStartForeground;
Class[] mStartForegroundSignature = new Class[] { int.class, Notification.class };
Object[] mStartForegroundArgs = new Object[2];
mStartForegroundArgs[0] = Integer.valueOf(id);
mStartForegroundArgs[1] = notification;
try
{
mStartForeground = getClass().getMethod("startForeground", mStartForegroundSignature);
mStartForeground.invoke(this, mStartForegroundArgs);
}
catch (NoSuchMethodException e)
{
Log.e(TAG, "Failed starting foreground notification using reflection", e);
}
catch (IllegalArgumentException e)
{
Log.e(TAG, "Failed starting foreground notification using reflection", e);
}
catch (IllegalAccessException e)
{
Log.e(TAG, "Failed starting foreground notification using reflection", e);
}
catch (InvocationTargetException e)
{
Log.e(TAG, "Failed starting foreground notification using reflection", e);
}
}
@SuppressWarnings("rawtypes")
private void stopForegroundReflected(boolean b)
{
Class[] mStopForegroundSignature = new Class[] { boolean.class };
Method mStopForeground;
Object[] mStopForegroundArgs = new Object[1];
mStopForegroundArgs[0] = Boolean.TRUE;
try
{
mStopForeground = getClass().getMethod("stopForeground", mStopForegroundSignature);
mStopForeground.invoke(this, mStopForegroundArgs);
}
catch (NoSuchMethodException e)
{
Log.e(TAG, "Failed stopping foreground notification using reflection", e);
}
catch (IllegalArgumentException e)
{
Log.e(TAG, "Failed stopping foreground notification using reflection", e);
}
catch (IllegalAccessException e)
{
Log.e(TAG, "Failed stopping foreground notification using reflection", e);
}
catch (InvocationTargetException e)
{
Log.e(TAG, "Failed stopping foreground notification using reflection", e);
}
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/logger/GPSLoggerService.java | Java | gpl3 | 53,293 |
package nl.sogeti.android.gpstracker.logger;
import android.net.Uri;
import android.location.Location;
interface IGPSLoggerServiceRemote {
int loggingState();
long startLogging();
void pauseLogging();
long resumeLogging();
void stopLogging();
Uri storeMediaUri(in Uri mediaUri);
boolean isMediaPrepared();
void storeDerivedDataSource(in String sourceName);
Location getLastWaypoint();
float getTrackedDistance();
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/logger/IGPSLoggerServiceRemote.aidl | AIDL | gpl3 | 465 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.logger;
import nl.sogeti.android.gpstracker.util.Constants;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.location.Location;
import android.net.Uri;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
/**
* Class to interact with the service that tracks and logs the locations
*
* @version $Id$
* @author rene (c) Jan 18, 2009, Sogeti B.V.
*/
public class GPSLoggerServiceManager
{
private static final String TAG = "OGT.GPSLoggerServiceManager";
private static final String REMOTE_EXCEPTION = "REMOTE_EXCEPTION";
private IGPSLoggerServiceRemote mGPSLoggerRemote;
public final Object mStartLock = new Object();
private boolean mBound = false;
/**
* Class for interacting with the main interface of the service.
*/
private ServiceConnection mServiceConnection;
private Runnable mOnServiceConnected;
public GPSLoggerServiceManager(Context ctx)
{
ctx.startService(new Intent(Constants.SERVICENAME));
}
public Location getLastWaypoint()
{
synchronized (mStartLock)
{
Location lastWaypoint = null;
try
{
if( mBound )
{
lastWaypoint = this.mGPSLoggerRemote.getLastWaypoint();
}
else
{
Log.w( TAG, "Remote interface to logging service not found. Started: " + mBound );
}
}
catch (RemoteException e)
{
Log.e( TAG, "Could get lastWaypoint GPSLoggerService.", e );
}
return lastWaypoint;
}
}
public float getTrackedDistance()
{
synchronized (mStartLock)
{
float distance = 0F;
try
{
if( mBound )
{
distance = this.mGPSLoggerRemote.getTrackedDistance();
}
else
{
Log.w( TAG, "Remote interface to logging service not found. Started: " + mBound );
}
}
catch (RemoteException e)
{
Log.e( TAG, "Could get tracked distance from GPSLoggerService.", e );
}
return distance;
}
}
public int getLoggingState()
{
synchronized (mStartLock)
{
int logging = Constants.UNKNOWN;
try
{
if( mBound )
{
logging = this.mGPSLoggerRemote.loggingState();
// Log.d( TAG, "mGPSLoggerRemote tells state to be "+logging );
}
else
{
Log.w( TAG, "Remote interface to logging service not found. Started: " + mBound );
}
}
catch (RemoteException e)
{
Log.e( TAG, "Could stat GPSLoggerService.", e );
}
return logging;
}
}
public boolean isMediaPrepared()
{
synchronized (mStartLock)
{
boolean prepared = false;
try
{
if( mBound )
{
prepared = this.mGPSLoggerRemote.isMediaPrepared();
}
else
{
Log.w( TAG, "Remote interface to logging service not found. Started: " + mBound );
}
}
catch (RemoteException e)
{
Log.e( TAG, "Could stat GPSLoggerService.", e );
}
return prepared;
}
}
public long startGPSLogging( String name )
{
synchronized (mStartLock)
{
if( mBound )
{
try
{
return this.mGPSLoggerRemote.startLogging();
}
catch (RemoteException e)
{
Log.e( TAG, "Could not start GPSLoggerService.", e );
}
}
return -1;
}
}
public void pauseGPSLogging()
{
synchronized (mStartLock)
{
if( mBound )
{
try
{
this.mGPSLoggerRemote.pauseLogging();
}
catch (RemoteException e)
{
Log.e( TAG, "Could not start GPSLoggerService.", e );
}
}
}
}
public long resumeGPSLogging()
{
synchronized (mStartLock)
{
if( mBound )
{
try
{
return this.mGPSLoggerRemote.resumeLogging();
}
catch (RemoteException e)
{
Log.e( TAG, "Could not start GPSLoggerService.", e );
}
}
return -1;
}
}
public void stopGPSLogging()
{
synchronized (mStartLock)
{
if( mBound )
{
try
{
this.mGPSLoggerRemote.stopLogging();
}
catch (RemoteException e)
{
Log.e( GPSLoggerServiceManager.REMOTE_EXCEPTION, "Could not stop GPSLoggerService.", e );
}
}
else
{
Log.e( TAG, "No GPSLoggerRemote service connected to this manager" );
}
}
}
public void storeDerivedDataSource( String datasource )
{
synchronized (mStartLock)
{
if( mBound )
{
try
{
this.mGPSLoggerRemote.storeDerivedDataSource( datasource );
}
catch (RemoteException e)
{
Log.e( GPSLoggerServiceManager.REMOTE_EXCEPTION, "Could not send datasource to GPSLoggerService.", e );
}
}
else
{
Log.e( TAG, "No GPSLoggerRemote service connected to this manager" );
}
}
}
public void storeMediaUri( Uri mediaUri )
{
synchronized (mStartLock)
{
if( mBound )
{
try
{
this.mGPSLoggerRemote.storeMediaUri( mediaUri );
}
catch (RemoteException e)
{
Log.e( GPSLoggerServiceManager.REMOTE_EXCEPTION, "Could not send media to GPSLoggerService.", e );
}
}
else
{
Log.e( TAG, "No GPSLoggerRemote service connected to this manager" );
}
}
}
/**
* Means by which an Activity lifecycle aware object hints about binding and unbinding
*
* @param onServiceConnected Run on main thread after the service is bound
*/
public void startup( Context context, final Runnable onServiceConnected )
{
// Log.d( TAG, "connectToGPSLoggerService()" );
synchronized (mStartLock)
{
if( !mBound )
{
mOnServiceConnected = onServiceConnected;
mServiceConnection = new ServiceConnection()
{
@Override
public void onServiceConnected( ComponentName className, IBinder service )
{
synchronized (mStartLock)
{
// Log.d( TAG, "onServiceConnected() "+ Thread.currentThread().getId() );
GPSLoggerServiceManager.this.mGPSLoggerRemote = IGPSLoggerServiceRemote.Stub.asInterface( service );
mBound = true;
}
if( mOnServiceConnected != null )
{
mOnServiceConnected.run();
mOnServiceConnected = null;
}
}
@Override
public void onServiceDisconnected( ComponentName className )
{
synchronized (mStartLock)
{
// Log.d( TAG, "onServiceDisconnected()"+ Thread.currentThread().getId() );
mBound = false;
}
}
};
context.bindService( new Intent( Constants.SERVICENAME ), this.mServiceConnection, Context.BIND_AUTO_CREATE );
}
else
{
Log.w( TAG, "Attempting to connect whilst already connected" );
}
}
}
/**
* Means by which an Activity lifecycle aware object hints about binding and unbinding
*/
public void shutdown(Context context)
{
// Log.d( TAG, "disconnectFromGPSLoggerService()" );
synchronized (mStartLock)
{
try
{
if( mBound )
{
// Log.d( TAG, "unbindService()"+this.mServiceConnection );
context.unbindService( this.mServiceConnection );
GPSLoggerServiceManager.this.mGPSLoggerRemote = null;
mServiceConnection = null;
mBound = false;
}
}
catch (IllegalArgumentException e)
{
Log.w( TAG, "Failed to unbind a service, prehaps the service disapearded?", e );
}
}
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/logger/GPSLoggerServiceManager.java | Java | gpl3 | 10,546 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.streaming;
import nl.sogeti.android.gpstracker.util.Constants;
import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
public class StreamUtils
{
@SuppressWarnings("unused")
private static final String TAG = "OGT.StreamUtils";
/**
* Initialize all appropriate stream listeners
* @param ctx
*/
public static void initStreams(final Context ctx)
{
SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(ctx);
boolean streams_enabled = sharedPreferences.getBoolean(Constants.BROADCAST_STREAM, false);
if (streams_enabled && sharedPreferences.getBoolean("VOICEOVER_ENABLED", false))
{
VoiceOver.initStreaming(ctx);
}
if (streams_enabled && sharedPreferences.getBoolean("CUSTOMUPLOAD_ENABLED", false))
{
CustomUpload.initStreaming(ctx);
}
}
/**
* Shutdown all stream listeners
*
* @param ctx
*/
public static void shutdownStreams(Context ctx)
{
VoiceOver.shutdownStreaming(ctx);
CustomUpload.shutdownStreaming(ctx);
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/streaming/StreamUtils.java | Java | gpl3 | 2,708 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.streaming;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.util.Constants;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.speech.tts.TextToSpeech;
import android.util.Log;
public class VoiceOver extends BroadcastReceiver implements TextToSpeech.OnInitListener
{
private static VoiceOver sVoiceOver = null;
private static final String TAG = "OGT.VoiceOver";
public static synchronized void initStreaming(Context ctx)
{
if( sVoiceOver != null )
{
shutdownStreaming(ctx);
}
sVoiceOver = new VoiceOver(ctx);
IntentFilter filter = new IntentFilter(Constants.STREAMBROADCAST);
ctx.registerReceiver(sVoiceOver, filter);
}
public static synchronized void shutdownStreaming(Context ctx)
{
if( sVoiceOver != null )
{
ctx.unregisterReceiver(sVoiceOver);
sVoiceOver.onShutdown();
sVoiceOver = null;
}
}
private TextToSpeech mTextToSpeech;
private int mVoiceStatus = -1;
private Context mContext;
public VoiceOver(Context ctx)
{
mContext = ctx.getApplicationContext();
mTextToSpeech = new TextToSpeech(mContext, this);
}
@Override
public void onInit(int status)
{
mVoiceStatus = status;
}
private void onShutdown()
{
mVoiceStatus = -1;
mTextToSpeech.shutdown();
}
@Override
public void onReceive(Context context, Intent intent)
{
if( mVoiceStatus == TextToSpeech.SUCCESS )
{
int meters = intent.getIntExtra(Constants.EXTRA_DISTANCE, 0);
int minutes = intent.getIntExtra(Constants.EXTRA_TIME, 0);
String myText = context.getString(R.string.voiceover_speaking, minutes, meters);
mTextToSpeech.speak(myText, TextToSpeech.QUEUE_ADD, null);
}
else
{
Log.w(TAG, "Voice stream failed TTS not ready");
}
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/streaming/VoiceOver.java | Java | gpl3 | 3,582 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.streaming;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.LinkedList;
import java.util.Queue;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.viewer.ApplicationPreferenceActivity;
import org.apache.ogt.http.HttpResponse;
import org.apache.ogt.http.StatusLine;
import org.apache.ogt.http.client.ClientProtocolException;
import org.apache.ogt.http.client.HttpClient;
import org.apache.ogt.http.client.methods.HttpGet;
import org.apache.ogt.http.impl.client.DefaultHttpClient;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.location.Location;
import android.net.Uri;
import android.preference.PreferenceManager;
import android.util.Log;
public class CustomUpload extends BroadcastReceiver
{
private static final String CUSTOMUPLOAD_BACKLOG_DEFAULT = "20";
private static CustomUpload sCustomUpload = null;
private static final String TAG = "OGT.CustomUpload";
private static final int NOTIFICATION_ID = R.string.customupload_failed;
private static Queue<HttpGet> sRequestBacklog = new LinkedList<HttpGet>();
public static synchronized void initStreaming(Context ctx)
{
if( sCustomUpload != null )
{
shutdownStreaming(ctx);
}
sCustomUpload = new CustomUpload();
sRequestBacklog = new LinkedList<HttpGet>();
IntentFilter filter = new IntentFilter(Constants.STREAMBROADCAST);
ctx.registerReceiver(sCustomUpload, filter);
}
public static synchronized void shutdownStreaming(Context ctx)
{
if( sCustomUpload != null )
{
ctx.unregisterReceiver(sCustomUpload);
sCustomUpload.onShutdown();
sCustomUpload = null;
}
}
private void onShutdown()
{
}
@Override
public void onReceive(Context context, Intent intent)
{
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
String prefUrl = preferences.getString(ApplicationPreferenceActivity.CUSTOMUPLOAD_URL, "http://www.example.com");
Integer prefBacklog = Integer.valueOf( preferences.getString(ApplicationPreferenceActivity.CUSTOMUPLOAD_BACKLOG, CUSTOMUPLOAD_BACKLOG_DEFAULT) );
Location loc = intent.getParcelableExtra(Constants.EXTRA_LOCATION);
Uri trackUri = intent.getParcelableExtra(Constants.EXTRA_TRACK);
String buildUrl = prefUrl;
buildUrl = buildUrl.replace("@LAT@", Double.toString(loc.getLatitude()));
buildUrl = buildUrl.replace("@LON@", Double.toString(loc.getLongitude()));
buildUrl = buildUrl.replace("@ID@", trackUri.getLastPathSegment());
buildUrl = buildUrl.replace("@TIME@", Long.toString(loc.getTime()));
buildUrl = buildUrl.replace("@SPEED@", Float.toString(loc.getSpeed()));
buildUrl = buildUrl.replace("@ACC@", Float.toString(loc.getAccuracy()));
buildUrl = buildUrl.replace("@ALT@", Double.toString(loc.getAltitude()));
buildUrl = buildUrl.replace("@BEAR@", Float.toString(loc.getBearing()));
HttpClient client = new DefaultHttpClient();
URI uploadUri;
try
{
uploadUri = new URI(buildUrl);
HttpGet currentRequest = new HttpGet(uploadUri );
sRequestBacklog.add(currentRequest);
if( sRequestBacklog.size() > prefBacklog )
{
sRequestBacklog.poll();
}
while( !sRequestBacklog.isEmpty() )
{
HttpGet request = sRequestBacklog.peek();
HttpResponse response = client.execute(request);
sRequestBacklog.poll();
StatusLine status = response.getStatusLine();
if (status.getStatusCode() != 200) {
throw new IOException("Invalid response from server: " + status.toString());
}
clearNotification(context);
}
}
catch (URISyntaxException e)
{
notifyError(context, e);
}
catch (ClientProtocolException e)
{
notifyError(context, e);
}
catch (IOException e)
{
notifyError(context, e);
}
}
private void notifyError(Context context, Exception e)
{
Log.e( TAG, "Custom upload failed", e);
String ns = Context.NOTIFICATION_SERVICE;
NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(ns);
int icon = R.drawable.ic_maps_indicator_current_position;
CharSequence tickerText = context.getText(R.string.customupload_failed);
long when = System.currentTimeMillis();
Notification notification = new Notification(icon, tickerText, when);
Context appContext = context.getApplicationContext();
CharSequence contentTitle = tickerText;
CharSequence contentText = e.getMessage();
Intent notificationIntent = new Intent(context, CustomUpload.class);
PendingIntent contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, 0);
notification.setLatestEventInfo(appContext, contentTitle, contentText, contentIntent);
notification.flags = Notification.FLAG_AUTO_CANCEL;
mNotificationManager.notify(NOTIFICATION_ID, notification);
}
private void clearNotification(Context context)
{
String ns = Context.NOTIFICATION_SERVICE;
NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(ns);
mNotificationManager.cancel(NOTIFICATION_ID);
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/streaming/CustomUpload.java | Java | gpl3 | 7,377 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.breadcrumbs;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OptionalDataException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Observable;
import java.util.Set;
import nl.sogeti.android.gpstracker.adapter.BreadcrumbsAdapter;
import nl.sogeti.android.gpstracker.db.GPStracking.MetaData;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.Pair;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.util.Log;
/**
* Model containing agregrated data retrieved from the GoBreadcrumbs.com API
*
* @version $Id:$
* @author rene (c) May 9, 2011, Sogeti B.V.
*/
public class BreadcrumbsTracks extends Observable
{
public static final String DESCRIPTION = "DESCRIPTION";
public static final String NAME = "NAME";
public static final String ENDTIME = "ENDTIME";
public static final String TRACK_ID = "BREADCRUMBS_TRACK_ID";
public static final String BUNDLE_ID = "BREADCRUMBS_BUNDLE_ID";
public static final String ACTIVITY_ID = "BREADCRUMBS_ACTIVITY_ID";
public static final String DIFFICULTY = "DIFFICULTY";
public static final String STARTTIME = "STARTTIME";
public static final String ISPUBLIC = "ISPUBLIC";
public static final String RATING = "RATING";
public static final String LATITUDE = "LATITUDE";
public static final String LONGITUDE = "LONGITUDE";
public static final String TOTALDISTANCE = "TOTALDISTANCE";
public static final String TOTALTIME = "TOTALTIME";
private static final String TAG = "OGT.BreadcrumbsTracks";
private static final Integer CACHE_VERSION = Integer.valueOf(3);
private static final String BREADCRUMSB_BUNDLES_CACHE_FILE = "breadcrumbs_bundles_cache.data";
private static final String BREADCRUMSB_ACTIVITY_CACHE_FILE = "breadcrumbs_activity_cache.data";
/**
* Time in milliseconds that a persisted breadcrumbs cache is used without a refresh
*/
private static final long CACHE_TIMEOUT = 1000 * 60;//1000*60*10 ;
/**
* Mapping from bundleId to a list of trackIds
*/
private static Map<Integer, List<Integer>> sBundlesWithTracks;
/**
* Map from activityId to a dictionary containing keys like NAME
*/
private static Map<Integer, Map<String, String>> sActivityMappings;
/**
* Map from bundleId to a dictionary containing keys like NAME and DESCRIPTION
*/
private static Map<Integer, Map<String, String>> sBundleMappings;
/**
* Map from trackId to a dictionary containing keys like NAME, ISPUBLIC, DESCRIPTION and more
*/
private static Map<Integer, Map<String, String>> sTrackMappings;
/**
* Cache of OGT Tracks that have a Breadcrumbs track id stored in the meta-data table
*/
private Map<Long, Integer> mSyncedTracks = null;
private static Set<Pair<Integer, Integer>> sScheduledTracksLoading;
static
{
BreadcrumbsTracks.initCacheVariables();
}
private static void initCacheVariables()
{
sBundlesWithTracks = new LinkedHashMap<Integer, List<Integer>>();
sActivityMappings = new HashMap<Integer, Map<String, String>>();
sBundleMappings = new HashMap<Integer, Map<String, String>>();
sTrackMappings = new HashMap<Integer, Map<String, String>>();
sScheduledTracksLoading = new HashSet<Pair<Integer, Integer>>();
}
private ContentResolver mResolver;
/**
* Constructor: create a new BreadcrumbsTracks.
*
* @param resolver Content resolver to obtain local Breadcrumbs references
*/
public BreadcrumbsTracks(ContentResolver resolver)
{
mResolver = resolver;
}
public void addActivity(Integer activityId, String activityName)
{
if (BreadcrumbsAdapter.DEBUG)
{
Log.d(TAG, "addActivity(Integer " + activityId + " String " + activityName + ")");
}
if (!sActivityMappings.containsKey(activityId))
{
sActivityMappings.put(activityId, new HashMap<String, String>());
}
sActivityMappings.get(activityId).put(NAME, activityName);
setChanged();
notifyObservers();
}
/**
* Add bundle to the track list
*
* @param activityId
* @param bundleId
* @param bundleName
* @param bundleDescription
*/
public void addBundle(Integer bundleId, String bundleName, String bundleDescription)
{
if (BreadcrumbsAdapter.DEBUG)
{
Log.d(TAG, "addBundle(Integer " + bundleId + ", String " + bundleName + ", String " + bundleDescription + ")");
}
if (!sBundleMappings.containsKey(bundleId))
{
sBundleMappings.put(bundleId, new HashMap<String, String>());
}
if (!sBundlesWithTracks.containsKey(bundleId))
{
sBundlesWithTracks.put(bundleId, new ArrayList<Integer>());
}
sBundleMappings.get(bundleId).put(NAME, bundleName);
sBundleMappings.get(bundleId).put(DESCRIPTION, bundleDescription);
setChanged();
notifyObservers();
}
/**
* Add track to tracklist
*
* @param trackId
* @param trackName
* @param bundleId
* @param trackDescription
* @param difficulty
* @param startTime
* @param endTime
* @param isPublic
* @param lat
* @param lng
* @param totalDistance
* @param totalTime
* @param trackRating
*/
public void addTrack(Integer trackId, String trackName, Integer bundleId, String trackDescription, String difficulty, String startTime, String endTime, String isPublic, Float lat, Float lng,
Float totalDistance, Integer totalTime, String trackRating)
{
if (BreadcrumbsAdapter.DEBUG)
{
Log.d(TAG, "addTrack(Integer " + trackId + ", String " + trackName + ", Integer " + bundleId + "...");
}
if (!sBundlesWithTracks.containsKey(bundleId))
{
sBundlesWithTracks.put(bundleId, new ArrayList<Integer>());
}
if (!sBundlesWithTracks.get(bundleId).contains(trackId))
{
sBundlesWithTracks.get(bundleId).add(trackId);
sScheduledTracksLoading.remove(Pair.create(Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE, trackId));
}
if (!sTrackMappings.containsKey(trackId))
{
sTrackMappings.put(trackId, new HashMap<String, String>());
}
putForTrack(trackId, NAME, trackName);
putForTrack(trackId, ISPUBLIC, isPublic);
putForTrack(trackId, STARTTIME, startTime);
putForTrack(trackId, ENDTIME, endTime);
putForTrack(trackId, DESCRIPTION, trackDescription);
putForTrack(trackId, DIFFICULTY, difficulty);
putForTrack(trackId, RATING, trackRating);
putForTrack(trackId, LATITUDE, lat);
putForTrack(trackId, LONGITUDE, lng);
putForTrack(trackId, TOTALDISTANCE, totalDistance);
putForTrack(trackId, TOTALTIME, totalTime);
notifyObservers();
}
public void addSyncedTrack(Long trackId, Integer bcTrackId)
{
if (mSyncedTracks == null)
{
isLocalTrackOnline(-1l);
}
mSyncedTracks.put(trackId, bcTrackId);
setChanged();
notifyObservers();
}
public void addTracksLoadingScheduled(Pair<Integer, Integer> item)
{
sScheduledTracksLoading.add(item);
setChanged();
notifyObservers();
}
/**
* Cleans old bundles based a set of all bundles
*
* @param mBundleIds
*/
public void setAllBundleIds(Set<Integer> mBundleIds)
{
for (Integer oldBundleId : getAllBundleIds())
{
if (!mBundleIds.contains(oldBundleId))
{
removeBundle(oldBundleId);
}
}
}
public void setAllTracksForBundleId(Integer mBundleId, Set<Integer> updatedbcTracksIdList)
{
List<Integer> trackIdList = sBundlesWithTracks.get(mBundleId);
for (int location = 0; location < trackIdList.size(); location++)
{
Integer oldTrackId = trackIdList.get(location);
if (!updatedbcTracksIdList.contains(oldTrackId))
{
removeTrack(mBundleId, oldTrackId);
}
}
setChanged();
notifyObservers();
}
private void putForTrack(Integer trackId, String key, Object value)
{
if (value != null)
{
sTrackMappings.get(trackId).put(key, value.toString());
}
setChanged();
notifyObservers();
}
/**
* Remove a bundle
*
* @param deletedId
*/
public void removeBundle(Integer deletedId)
{
sBundleMappings.remove(deletedId);
sBundlesWithTracks.remove(deletedId);
setChanged();
notifyObservers();
}
/**
* Remove a track
*
* @param deletedId
*/
public void removeTrack(Integer bundleId, Integer trackId)
{
sTrackMappings.remove(trackId);
if (sBundlesWithTracks.containsKey(bundleId))
{
sBundlesWithTracks.get(bundleId).remove(trackId);
}
setChanged();
notifyObservers();
mResolver.delete(MetaData.CONTENT_URI, MetaData.TRACK + " = ? AND " + MetaData.KEY + " = ? ", new String[] { trackId.toString(), TRACK_ID });
if (mSyncedTracks != null && mSyncedTracks.containsKey(trackId))
{
mSyncedTracks.remove(trackId);
}
}
public int positions()
{
int size = 0;
for (Integer bundleId : sBundlesWithTracks.keySet())
{
// One row for the Bundle header
size += 1;
int bundleSize = sBundlesWithTracks.get(bundleId) != null ? sBundlesWithTracks.get(bundleId).size() : 0;
// One row per track in each bundle
size += bundleSize;
}
return size;
}
public Integer getBundleIdForTrackId(Integer trackId)
{
for (Integer bundlId : sBundlesWithTracks.keySet())
{
List<Integer> trackIds = sBundlesWithTracks.get(bundlId);
if (trackIds.contains(trackId))
{
return bundlId;
}
}
return null;
}
public Integer[] getAllActivityIds()
{
return sActivityMappings.keySet().toArray(new Integer[sActivityMappings.keySet().size()]);
}
/**
* Get all bundles
*
* @return
*/
public Integer[] getAllBundleIds()
{
return sBundlesWithTracks.keySet().toArray(new Integer[sBundlesWithTracks.keySet().size()]);
}
/**
* @param position list postition 0...n
* @return a pair of a TYPE and an ID
*/
public List<Pair<Integer, Integer>> getAllItems()
{
List<Pair<Integer, Integer>> items = new LinkedList<Pair<Integer, Integer>>();
for (Integer bundleId : sBundlesWithTracks.keySet())
{
items.add(Pair.create(Constants.BREADCRUMBS_BUNDLE_ITEM_VIEW_TYPE, bundleId));
for(Integer trackId : sBundlesWithTracks.get(bundleId))
{
items.add(Pair.create(Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE, trackId));
}
}
return items;
}
public List<Pair<Integer, Integer>> getActivityList()
{
List<Pair<Integer, Integer>> items = new LinkedList<Pair<Integer, Integer>>();
for (Integer activityId : sActivityMappings.keySet())
{
Pair<Integer, Integer> pair = Pair.create(Constants.BREADCRUMBS_ACTIVITY_ITEM_VIEW_TYPE, activityId);
pair.overrideToString(getValueForItem(pair, NAME));
items.add(pair);
}
return items;
}
public List<Pair<Integer, Integer>> getBundleList()
{
List<Pair<Integer, Integer>> items = new LinkedList<Pair<Integer, Integer>>();
for (Integer bundleId : sBundleMappings.keySet())
{
Pair<Integer, Integer> pair = Pair.create(Constants.BREADCRUMBS_BUNDLE_ITEM_VIEW_TYPE, bundleId);
pair.overrideToString(getValueForItem(pair, NAME));
items.add(pair);
}
return items;
}
public String getValueForItem(Pair<Integer, Integer> item, String key)
{
String value = null;
switch (item.first)
{
case Constants.BREADCRUMBS_BUNDLE_ITEM_VIEW_TYPE:
value = sBundleMappings.get(item.second).get(key);
break;
case Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE:
value = sTrackMappings.get(item.second).get(key);
break;
case Constants.BREADCRUMBS_ACTIVITY_ITEM_VIEW_TYPE:
value = sActivityMappings.get(item.second).get(key);
break;
default:
value = null;
break;
}
return value;
}
private boolean isLocalTrackOnline(Long qtrackId)
{
if (mSyncedTracks == null)
{
mSyncedTracks = new HashMap<Long, Integer>();
Cursor cursor = null;
try
{
cursor = mResolver.query(MetaData.CONTENT_URI, new String[] { MetaData.TRACK, MetaData.VALUE }, MetaData.KEY + " = ? ", new String[] { TRACK_ID }, null);
if (cursor.moveToFirst())
{
do
{
Long trackId = cursor.getLong(0);
try
{
Integer bcTrackId = Integer.valueOf(cursor.getString(1));
mSyncedTracks.put(trackId, bcTrackId);
}
catch (NumberFormatException e)
{
Log.w(TAG, "Illigal value stored as track id", e);
}
}
while (cursor.moveToNext());
}
}
finally
{
if (cursor != null)
{
cursor.close();
}
}
setChanged();
notifyObservers();
}
boolean synced = mSyncedTracks.containsKey(qtrackId);
return synced;
}
public boolean isLocalTrackSynced(Long qtrackId)
{
boolean uploaded = isLocalTrackOnline(qtrackId);
boolean synced = sTrackMappings.containsKey(mSyncedTracks.get(qtrackId));
return uploaded && synced;
}
public boolean areTracksLoaded(Pair<Integer, Integer> item)
{
return sBundlesWithTracks.containsKey(item.second) && item.first == Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE;
}
public boolean areTracksLoadingScheduled(Pair<Integer, Integer> item)
{
return sScheduledTracksLoading.contains(item);
}
/**
* Read the static breadcrumbs data from private file
*
* @param ctx
* @return is refresh is needed
*/
@SuppressWarnings("unchecked")
public boolean readCache(Context ctx)
{
FileInputStream fis = null;
ObjectInputStream ois = null;
Date bundlesPersisted = null, activitiesPersisted = null;
Object[] cache;
synchronized (BREADCRUMSB_BUNDLES_CACHE_FILE)
{
try
{
fis = ctx.openFileInput(BREADCRUMSB_BUNDLES_CACHE_FILE);
ois = new ObjectInputStream(fis);
cache = (Object[]) ois.readObject();
// new Object[] { CACHE_VERSION, new Date(), sActivitiesWithBundles, sBundlesWithTracks, sBundleMappings, sTrackMappings };
if (cache[0] instanceof Integer && CACHE_VERSION.equals(cache[0]))
{
bundlesPersisted = (Date) cache[1];
Map<Integer, List<Integer>> bundles = (Map<Integer, List<Integer>>) cache[2];
Map<Integer, Map<String, String>> bundlemappings = (Map<Integer, Map<String, String>>) cache[3];
Map<Integer, Map<String, String>> trackmappings = (Map<Integer, Map<String, String>>) cache[4];
sBundlesWithTracks = bundles != null ? bundles : sBundlesWithTracks;
sBundleMappings = bundlemappings != null ? bundlemappings : sBundleMappings;
sTrackMappings = trackmappings != null ? trackmappings : sTrackMappings;
}
else
{
clearPersistentCache(ctx);
}
fis = ctx.openFileInput(BREADCRUMSB_ACTIVITY_CACHE_FILE);
ois = new ObjectInputStream(fis);
cache = (Object[]) ois.readObject();
// new Object[] { CACHE_VERSION, new Date(), sActivityMappings };
if (cache[0] instanceof Integer && CACHE_VERSION.equals(cache[0]))
{
activitiesPersisted = (Date) cache[1];
Map<Integer, Map<String, String>> activitymappings = (Map<Integer, Map<String, String>>) cache[2];
sActivityMappings = activitymappings != null ? activitymappings : sActivityMappings;
}
else
{
clearPersistentCache(ctx);
}
}
catch (OptionalDataException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
catch (ClassNotFoundException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
catch (IOException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
catch (ClassCastException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
catch (ArrayIndexOutOfBoundsException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
finally
{
if (fis != null)
{
try
{
fis.close();
}
catch (IOException e)
{
Log.w(TAG, "Error closing file stream after reading cache", e);
}
}
if (ois != null)
{
try
{
ois.close();
}
catch (IOException e)
{
Log.w(TAG, "Error closing object stream after reading cache", e);
}
}
}
}
setChanged();
notifyObservers();
boolean refreshNeeded = false;
refreshNeeded = refreshNeeded || bundlesPersisted == null || activitiesPersisted == null;
refreshNeeded = refreshNeeded || (activitiesPersisted.getTime() < new Date().getTime() - CACHE_TIMEOUT * 10);
refreshNeeded = refreshNeeded || (bundlesPersisted.getTime() < new Date().getTime() - CACHE_TIMEOUT);
return refreshNeeded;
}
public void persistCache(Context ctx)
{
FileOutputStream fos = null;
ObjectOutputStream oos = null;
Object[] cache;
synchronized (BREADCRUMSB_BUNDLES_CACHE_FILE)
{
try
{
fos = ctx.openFileOutput(BREADCRUMSB_BUNDLES_CACHE_FILE, Context.MODE_PRIVATE);
oos = new ObjectOutputStream(fos);
cache = new Object[] { CACHE_VERSION, new Date(), sBundlesWithTracks, sBundleMappings, sTrackMappings };
oos.writeObject(cache);
fos = ctx.openFileOutput(BREADCRUMSB_ACTIVITY_CACHE_FILE, Context.MODE_PRIVATE);
oos = new ObjectOutputStream(fos);
cache = new Object[] { CACHE_VERSION, new Date(), sActivityMappings };
oos.writeObject(cache);
}
catch (FileNotFoundException e)
{
Log.e(TAG, "Error in file stream during persist cache", e);
}
catch (IOException e)
{
Log.e(TAG, "Error in object stream during persist cache", e);
}
finally
{
if (fos != null)
{
try
{
fos.close();
}
catch (IOException e)
{
Log.w(TAG, "Error closing file stream after writing cache", e);
}
}
if (oos != null)
{
try
{
oos.close();
}
catch (IOException e)
{
Log.w(TAG, "Error closing object stream after writing cache", e);
}
}
}
}
}
public void clearAllCache(Context ctx)
{
BreadcrumbsTracks.initCacheVariables();
setChanged();
clearPersistentCache(ctx);
notifyObservers();
}
public void clearPersistentCache(Context ctx)
{
Log.w(TAG, "Deleting old Breadcrumbs cache files");
synchronized (BREADCRUMSB_BUNDLES_CACHE_FILE)
{
ctx.deleteFile(BREADCRUMSB_ACTIVITY_CACHE_FILE);
ctx.deleteFile(BREADCRUMSB_BUNDLES_CACHE_FILE);
}
}
@Override
public String toString()
{
return "BreadcrumbsTracks [mActivityMappings=" + sActivityMappings + ", mBundleMappings=" + sBundleMappings + ", mTrackMappings=" + sTrackMappings + ", mActivities=" + sActivityMappings
+ ", mBundles=" + sBundlesWithTracks + "]";
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/breadcrumbs/BreadcrumbsTracks.java | Java | gpl3 | 22,876 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.breadcrumbs;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Set;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.tasks.XmlCreator;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.adapter.BreadcrumbsAdapter;
import oauth.signpost.OAuthConsumer;
import oauth.signpost.exception.OAuthCommunicationException;
import oauth.signpost.exception.OAuthExpectationFailedException;
import oauth.signpost.exception.OAuthMessageSignerException;
import org.apache.ogt.http.Header;
import org.apache.ogt.http.HttpEntity;
import org.apache.ogt.http.HttpResponse;
import org.apache.ogt.http.client.methods.HttpGet;
import org.apache.ogt.http.client.methods.HttpUriRequest;
import org.apache.ogt.http.impl.client.DefaultHttpClient;
import org.apache.ogt.http.util.EntityUtils;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
import android.content.Context;
import android.util.Log;
/**
* An asynchronous task that communicates with Twitter to retrieve a request
* token. (OAuthGetRequestToken) After receiving the request token from Twitter,
* pop a browser to the user to authorize the Request Token.
* (OAuthAuthorizeToken)
*/
public class GetBreadcrumbsBundlesTask extends BreadcrumbsTask
{
final String TAG = "OGT.GetBreadcrumbsBundlesTask";
private OAuthConsumer mConsumer;
private DefaultHttpClient mHttpclient;
private Set<Integer> mBundleIds;
private LinkedList<Object[]> mBundles;
/**
* We pass the OAuth consumer and provider.
*
* @param mContext Required to be able to start the intent to launch the
* browser.
* @param httpclient
* @param listener
* @param provider The OAuthProvider object
* @param mConsumer The OAuthConsumer object
*/
public GetBreadcrumbsBundlesTask(Context context, BreadcrumbsService adapter, ProgressListener listener, DefaultHttpClient httpclient, OAuthConsumer consumer)
{
super(context, adapter, listener);
mHttpclient = httpclient;
mConsumer = consumer;
}
/**
* Retrieve the OAuth Request Token and present a browser to the user to
* authorize the token.
*/
@Override
protected Void doInBackground(Void... params)
{
HttpEntity responseEntity = null;
mBundleIds = new HashSet<Integer>();
mBundles = new LinkedList<Object[]>();
try
{
HttpUriRequest request = new HttpGet("http://api.gobreadcrumbs.com/v1/bundles.xml");
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
mConsumer.sign(request);
if( BreadcrumbsAdapter.DEBUG )
{
Log.d( TAG, "Execute request: "+request.getURI() );
for( Header header : request.getAllHeaders() )
{
Log.d( TAG, " with header: "+header.toString());
}
}
HttpResponse response = mHttpclient.execute(request);
responseEntity = response.getEntity();
InputStream is = responseEntity.getContent();
InputStream stream = new BufferedInputStream(is, 8192);
if( BreadcrumbsAdapter.DEBUG )
{
stream = XmlCreator.convertStreamToLoggedStream(TAG, stream);
}
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
factory.setNamespaceAware(true);
XmlPullParser xpp = factory.newPullParser();
xpp.setInput(stream, "UTF-8");
String tagName = null;
int eventType = xpp.getEventType();
String bundleName = null, bundleDescription = null;
Integer bundleId = null;
while (eventType != XmlPullParser.END_DOCUMENT)
{
if (eventType == XmlPullParser.START_TAG)
{
tagName = xpp.getName();
}
else if (eventType == XmlPullParser.END_TAG)
{
if ("bundle".equals(xpp.getName()) && bundleId != null)
{
mBundles.add( new Object[]{bundleId, bundleName, bundleDescription} );
}
tagName = null;
}
else if (eventType == XmlPullParser.TEXT)
{
if ("description".equals(tagName))
{
bundleDescription = xpp.getText();
}
else if ("id".equals(tagName))
{
bundleId = Integer.parseInt(xpp.getText());
mBundleIds.add(bundleId);
}
else if ("name".equals(tagName))
{
bundleName = xpp.getText();
}
}
eventType = xpp.next();
}
}
catch (OAuthMessageSignerException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_bundle), e, "Failed to sign the request with authentication signature");
}
catch (OAuthExpectationFailedException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_bundle), e, "The request did not authenticate");
}
catch (OAuthCommunicationException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_bundle), e, "The authentication communication failed");
}
catch (IOException e)
{
handleError(mContext.getString(R.string.taskerror_breadcrumbs_bundle), e, "A problem during communication");
}
catch (XmlPullParserException e)
{
handleError(mContext.getString(R.string.taskerror_breadcrumbs_bundle), e, "A problem while reading the XML data");
}
catch (IllegalStateException e)
{
handleError(mContext.getString(R.string.taskerror_breadcrumbs_bundle), e, "A problem during communication");
}
finally
{
if (responseEntity != null)
{
try
{
EntityUtils.consume(responseEntity);
}
catch (IOException e)
{
Log.w(TAG, "Failed closing inputstream");
}
}
}
return null;
}
@Override
protected void updateTracksData(BreadcrumbsTracks tracks)
{
tracks.setAllBundleIds( mBundleIds );
for( Object[] bundle : mBundles )
{
Integer bundleId = (Integer) bundle[0];
String bundleName = (String) bundle[1];
String bundleDescription = (String) bundle[2];
tracks.addBundle(bundleId, bundleName, bundleDescription);
}
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/breadcrumbs/GetBreadcrumbsBundlesTask.java | Java | gpl3 | 8,517 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.breadcrumbs;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedList;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.tasks.XmlCreator;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.adapter.BreadcrumbsAdapter;
import nl.sogeti.android.gpstracker.util.Pair;
import oauth.signpost.OAuthConsumer;
import oauth.signpost.exception.OAuthCommunicationException;
import oauth.signpost.exception.OAuthExpectationFailedException;
import oauth.signpost.exception.OAuthMessageSignerException;
import org.apache.ogt.http.Header;
import org.apache.ogt.http.HttpEntity;
import org.apache.ogt.http.HttpResponse;
import org.apache.ogt.http.client.methods.HttpGet;
import org.apache.ogt.http.client.methods.HttpUriRequest;
import org.apache.ogt.http.impl.client.DefaultHttpClient;
import org.apache.ogt.http.util.EntityUtils;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
import android.content.Context;
import android.util.Log;
/**
* An asynchronous task that communicates with Twitter to retrieve a request
* token. (OAuthGetRequestToken) After receiving the request token from Twitter,
* pop a browser to the user to authorize the Request Token.
* (OAuthAuthorizeToken)
*/
public class GetBreadcrumbsActivitiesTask extends BreadcrumbsTask
{
private LinkedList<Pair<Integer, String>> mActivities;
final String TAG = "OGT.GetBreadcrumbsActivitiesTask";
private OAuthConsumer mConsumer;
private DefaultHttpClient mHttpClient;
/**
* We pass the OAuth consumer and provider.
*
* @param mContext Required to be able to start the intent to launch the
* browser.
* @param httpclient
* @param provider The OAuthProvider object
* @param mConsumer The OAuthConsumer object
*/
public GetBreadcrumbsActivitiesTask(Context context, BreadcrumbsService adapter, ProgressListener listener, DefaultHttpClient httpclient, OAuthConsumer consumer)
{
super(context, adapter, listener);
mHttpClient = httpclient;
mConsumer = consumer;
}
/**
* Retrieve the OAuth Request Token and present a browser to the user to
* authorize the token.
*/
@Override
protected Void doInBackground(Void... params)
{
mActivities = new LinkedList<Pair<Integer,String>>();
HttpEntity responseEntity = null;
try
{
HttpUriRequest request = new HttpGet("http://api.gobreadcrumbs.com/v1/activities.xml");
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
mConsumer.sign(request);
if( BreadcrumbsAdapter.DEBUG )
{
Log.d( TAG, "Execute request: "+request.getURI() );
for( Header header : request.getAllHeaders() )
{
Log.d( TAG, " with header: "+header.toString());
}
}
HttpResponse response = mHttpClient.execute(request);
responseEntity = response.getEntity();
InputStream is = responseEntity.getContent();
InputStream stream = new BufferedInputStream(is, 8192);
if( BreadcrumbsAdapter.DEBUG )
{
stream = XmlCreator.convertStreamToLoggedStream(TAG, stream);
}
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
factory.setNamespaceAware(true);
XmlPullParser xpp = factory.newPullParser();
xpp.setInput(stream, "UTF-8");
String tagName = null;
int eventType = xpp.getEventType();
String activityName = null;
Integer activityId = null;
while (eventType != XmlPullParser.END_DOCUMENT)
{
if (eventType == XmlPullParser.START_TAG)
{
tagName = xpp.getName();
}
else if (eventType == XmlPullParser.END_TAG)
{
if ("activity".equals(xpp.getName()) && activityId != null && activityName != null)
{
mActivities.add(new Pair<Integer, String>(activityId, activityName));
}
tagName = null;
}
else if (eventType == XmlPullParser.TEXT)
{
if ("id".equals(tagName))
{
activityId = Integer.parseInt(xpp.getText());
}
else if ("name".equals(tagName))
{
activityName = xpp.getText();
}
}
eventType = xpp.next();
}
}
catch (OAuthMessageSignerException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_activity), e, "Failed to sign the request with authentication signature");
}
catch (OAuthExpectationFailedException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_activity), e, "The request did not authenticate");
}
catch (OAuthCommunicationException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_activity), e, "The authentication communication failed");
}
catch (IOException e)
{
handleError(mContext.getString(R.string.taskerror_breadcrumbs_activity), e, "A problem during communication");
}
catch (XmlPullParserException e)
{
handleError(mContext.getString(R.string.taskerror_breadcrumbs_activity), e, "A problem while reading the XML data");
}
finally
{
if (responseEntity != null)
{
try
{
EntityUtils.consume(responseEntity);
}
catch (IOException e)
{
Log.e(TAG, "Failed to close the content stream", e);
}
}
}
return null;
}
@Override
protected void updateTracksData( BreadcrumbsTracks tracks )
{
for( Pair<Integer, String> activity : mActivities )
{
tracks.addActivity(activity.first, activity.second);
}
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/breadcrumbs/GetBreadcrumbsActivitiesTask.java | Java | gpl3 | 7,926 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.breadcrumbs;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Set;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.tasks.XmlCreator;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.adapter.BreadcrumbsAdapter;
import oauth.signpost.OAuthConsumer;
import oauth.signpost.exception.OAuthCommunicationException;
import oauth.signpost.exception.OAuthExpectationFailedException;
import oauth.signpost.exception.OAuthMessageSignerException;
import org.apache.ogt.http.Header;
import org.apache.ogt.http.HttpEntity;
import org.apache.ogt.http.HttpResponse;
import org.apache.ogt.http.client.methods.HttpGet;
import org.apache.ogt.http.client.methods.HttpUriRequest;
import org.apache.ogt.http.impl.client.DefaultHttpClient;
import org.apache.ogt.http.util.EntityUtils;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
import android.content.Context;
import android.util.Log;
/**
* An asynchronous task that communicates with Twitter to retrieve a request
* token. (OAuthGetRequestToken) After receiving the request token from Twitter,
* pop a browser to the user to authorize the Request Token.
* (OAuthAuthorizeToken)
*/
public class GetBreadcrumbsTracksTask extends BreadcrumbsTask
{
final String TAG = "OGT.GetBreadcrumbsTracksTask";
private OAuthConsumer mConsumer;
private DefaultHttpClient mHttpclient;
private Integer mBundleId;
private LinkedList<Object[]> mTracks;
/**
* We pass the OAuth consumer and provider.
*
* @param mContext Required to be able to start the intent to launch the
* browser.
* @param httpclient
* @param provider The OAuthProvider object
* @param mConsumer The OAuthConsumer object
*/
public GetBreadcrumbsTracksTask(Context context, BreadcrumbsService adapter, ProgressListener listener, DefaultHttpClient httpclient, OAuthConsumer consumer, Integer bundleId)
{
super(context, adapter, listener);
mHttpclient = httpclient;
mConsumer = consumer;
mBundleId = bundleId;
}
/**
* Retrieve the OAuth Request Token and present a browser to the user to
* authorize the token.
*/
@Override
protected Void doInBackground(Void... params)
{
mTracks = new LinkedList<Object[]>();
HttpEntity responseEntity = null;
try
{
HttpUriRequest request = new HttpGet("http://api.gobreadcrumbs.com/v1/bundles/"+mBundleId+"/tracks.xml");
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
mConsumer.sign(request);
if( BreadcrumbsAdapter.DEBUG )
{
Log.d( TAG, "Execute request: "+request.getURI() );
for( Header header : request.getAllHeaders() )
{
Log.d( TAG, " with header: "+header.toString());
}
}
HttpResponse response = mHttpclient.execute(request);
responseEntity = response.getEntity();
InputStream is = responseEntity.getContent();
InputStream stream = new BufferedInputStream(is, 8192);
if( BreadcrumbsAdapter.DEBUG )
{
stream = XmlCreator.convertStreamToLoggedStream(TAG, stream);
}
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
factory.setNamespaceAware(true);
XmlPullParser xpp = factory.newPullParser();
xpp.setInput(stream, "UTF-8");
String tagName = null;
int eventType = xpp.getEventType();
String trackName = null, description = null, difficulty = null, startTime = null, endTime = null, trackRating = null, isPublic = null;
Integer trackId = null, bundleId = null, totalTime = null;
Float lat = null, lng = null, totalDistance = null;
while (eventType != XmlPullParser.END_DOCUMENT)
{
if (eventType == XmlPullParser.START_TAG)
{
tagName = xpp.getName();
}
else if (eventType == XmlPullParser.END_TAG)
{
if ("track".equals(xpp.getName()) && trackId != null && bundleId != null)
{
mTracks.add(new Object[] { trackId, trackName, bundleId, description, difficulty, startTime, endTime, isPublic, lat, lng, totalDistance,
totalTime, trackRating });
}
tagName = null;
}
else if (eventType == XmlPullParser.TEXT)
{
if ("bundle-id".equals(tagName))
{
bundleId = Integer.parseInt(xpp.getText());
}
else if ("description".equals(tagName))
{
description = xpp.getText();
}
else if ("difficulty".equals(tagName))
{
difficulty = xpp.getText();
}
else if ("start-time".equals(tagName))
{
startTime = xpp.getText();
}
else if ("end-time".equals(tagName))
{
endTime = xpp.getText();
}
else if ("id".equals(tagName))
{
trackId = Integer.parseInt(xpp.getText());
}
else if ("is-public".equals(tagName))
{
isPublic = xpp.getText();
}
else if ("lat".equals(tagName))
{
lat = Float.parseFloat(xpp.getText());
}
else if ("lng".equals(tagName))
{
lng = Float.parseFloat(xpp.getText());
}
else if ("name".equals(tagName))
{
trackName = xpp.getText();
}
else if ("track-rating".equals(tagName))
{
trackRating = xpp.getText();
}
}
eventType = xpp.next();
}
}
catch (OAuthMessageSignerException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_track), e, "Failed to sign the request with authentication signature");
}
catch (OAuthExpectationFailedException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_track), e, "The request did not authenticate");
}
catch (OAuthCommunicationException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_track), e, "The authentication communication failed");
}
catch (IOException e)
{
handleError(mContext.getString(R.string.taskerror_breadcrumbs_track), e, "A problem during communication");
}
catch (XmlPullParserException e)
{
handleError(mContext.getString(R.string.taskerror_breadcrumbs_track), e, "A problem while reading the XML data");
}
finally
{
if (responseEntity != null)
{
try
{
EntityUtils.consume(responseEntity);
}
catch (IOException e)
{
Log.e(TAG, "Failed to close the content stream", e);
}
}
}
return null;
}
@Override
protected void updateTracksData(BreadcrumbsTracks tracks)
{
Set<Integer> mTracksIds = new HashSet<Integer>() ;
for (Object[] track : mTracks)
{
mTracksIds.add((Integer) track[0]);
}
tracks.setAllTracksForBundleId( mBundleId, mTracksIds );
for (Object[] track : mTracks)
{
Integer trackId = (Integer) track[0];
String trackName = (String) track[1];
Integer bundleId = (Integer) track[2];
String description = (String) track[3];
String difficulty = (String) track[4];
String startTime = (String) track[5];
String endTime = (String) track[6];
String isPublic = (String) track[7];
Float lat = (Float) track[8];
Float lng = (Float) track[9];
Float totalDistance = (Float) track[10];
Integer totalTime = (Integer) track[11];
String trackRating = (String) track[12];
tracks.addTrack(trackId, trackName, bundleId, description, difficulty, startTime, endTime, isPublic, lat, lng, totalDistance, totalTime, trackRating);
}
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/breadcrumbs/GetBreadcrumbsTracksTask.java | Java | gpl3 | 10,413 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Oct 20, 2012 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*/
package nl.sogeti.android.gpstracker.breadcrumbs;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.oauth.PrepareRequestTokenActivity;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.Pair;
import oauth.signpost.commonshttp.CommonsHttpOAuthConsumer;
import org.apache.ogt.http.conn.ClientConnectionManager;
import org.apache.ogt.http.conn.scheme.PlainSocketFactory;
import org.apache.ogt.http.conn.scheme.Scheme;
import org.apache.ogt.http.conn.scheme.SchemeRegistry;
import org.apache.ogt.http.impl.client.DefaultHttpClient;
import org.apache.ogt.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Binder;
import android.os.Build;
import android.os.IBinder;
import android.preference.PreferenceManager;
import android.util.Log;
/**
* ????
*
* @version $Id:$
* @author rene (c) Oct 20, 2012, Sogeti B.V.
*/
public class BreadcrumbsService extends Service implements Observer, ProgressListener
{
public static final String OAUTH_TOKEN = "breadcrumbs_oauth_token";
public static final String OAUTH_TOKEN_SECRET = "breadcrumbs_oauth_secret";
private static final String TAG = "OGT.BreadcrumbsService";
public static final String NOTIFY_DATA_SET_CHANGED = "nl.sogeti.android.gpstracker.intent.action.NOTIFY_DATA_SET_CHANGED";
public static final String NOTIFY_PROGRESS_CHANGED = "nl.sogeti.android.gpstracker.intent.action.NOTIFY_PROGRESS_CHANGED";
public static final String PROGRESS_INDETERMINATE = null;
public static final String PROGRESS = null;
public static final String PROGRESS_STATE = null;
public static final String PROGRESS_RESULT = null;
public static final String PROGRESS_TASK = null;
public static final String PROGRESS_MESSAGE = null;
public static final int PROGRESS_STARTED = 1;
public static final int PROGRESS_FINISHED = 2;
public static final int PROGRESS_ERROR = 3;
private final IBinder mBinder = new LocalBinder();
private BreadcrumbsTracks mTracks;
private DefaultHttpClient mHttpClient;
private OnSharedPreferenceChangeListener tokenChangedListener;
private boolean mFinishing;
boolean mAuthorized;
ExecutorService mExecutor;
@Override
public void onCreate()
{
super.onCreate();
mExecutor = Executors.newFixedThreadPool(1);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
ClientConnectionManager cm = new ThreadSafeClientConnManager(schemeRegistry);
mHttpClient = new DefaultHttpClient(cm);
mTracks = new BreadcrumbsTracks(this.getContentResolver());
mTracks.addObserver(this);
connectionSetup();
}
@Override
public void onDestroy()
{
if (tokenChangedListener != null)
{
PreferenceManager.getDefaultSharedPreferences(this).unregisterOnSharedPreferenceChangeListener(tokenChangedListener);
}
mAuthorized = false;
mFinishing = true;
new AsyncTask<Void, Void, Void>()
{
public void executeOn(Executor executor)
{
if (Build.VERSION.SDK_INT >= 11)
{
executeOnExecutor(executor);
}
else
{
execute();
}
}
@Override
protected Void doInBackground(Void... params)
{
mHttpClient.getConnectionManager().shutdown();
mExecutor.shutdown();
mHttpClient = null;
return null;
}
}.executeOn(mExecutor);
mTracks.persistCache(this);
super.onDestroy();
}
/**
* Class used for the client Binder. Because we know this service always runs in the same process as its clients, we don't need to deal with IPC.
*/
public class LocalBinder extends Binder
{
public BreadcrumbsService getService()
{
return BreadcrumbsService.this;
}
}
/**
* @see android.app.Service#onBind(android.content.Intent)
*/
@Override
public IBinder onBind(Intent intent)
{
return mBinder;
}
private boolean connectionSetup()
{
final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
String token = prefs.getString(OAUTH_TOKEN, "");
String secret = prefs.getString(OAUTH_TOKEN_SECRET, "");
mAuthorized = !"".equals(token) && !"".equals(secret);
if (mAuthorized)
{
CommonsHttpOAuthConsumer consumer = getOAuthConsumer();
if (mTracks.readCache(this))
{
new GetBreadcrumbsActivitiesTask(this, this, this, mHttpClient, consumer).executeOn(mExecutor);
new GetBreadcrumbsBundlesTask(this, this, this, mHttpClient, consumer).executeOn(mExecutor);
}
}
return mAuthorized;
}
public CommonsHttpOAuthConsumer getOAuthConsumer()
{
final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
String token = prefs.getString(OAUTH_TOKEN, "");
String secret = prefs.getString(OAUTH_TOKEN_SECRET, "");
CommonsHttpOAuthConsumer consumer = new CommonsHttpOAuthConsumer(this.getString(R.string.CONSUMER_KEY), this.getString(R.string.CONSUMER_SECRET));
consumer.setTokenWithSecret(token, secret);
return consumer;
}
public void removeAuthentication()
{
Log.w(TAG, "Removing Breadcrumbs OAuth tokens");
Editor e = PreferenceManager.getDefaultSharedPreferences(this).edit();
e.remove(OAUTH_TOKEN);
e.remove(OAUTH_TOKEN_SECRET);
e.commit();
}
/**
* Use a locally stored token or start the request activity to collect one
*/
public void collectBreadcrumbsOauthToken()
{
if (!connectionSetup())
{
tokenChangedListener = new OnSharedPreferenceChangeListener()
{
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
{
if (OAUTH_TOKEN.equals(key))
{
PreferenceManager.getDefaultSharedPreferences(BreadcrumbsService.this).unregisterOnSharedPreferenceChangeListener(tokenChangedListener);
connectionSetup();
}
}
};
PreferenceManager.getDefaultSharedPreferences(this).registerOnSharedPreferenceChangeListener(tokenChangedListener);
Intent i = new Intent(this.getApplicationContext(), PrepareRequestTokenActivity.class);
i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
i.putExtra(PrepareRequestTokenActivity.OAUTH_TOKEN_PREF, OAUTH_TOKEN);
i.putExtra(PrepareRequestTokenActivity.OAUTH_TOKEN_SECRET_PREF, OAUTH_TOKEN_SECRET);
i.putExtra(PrepareRequestTokenActivity.CONSUMER_KEY, this.getString(R.string.CONSUMER_KEY));
i.putExtra(PrepareRequestTokenActivity.CONSUMER_SECRET, this.getString(R.string.CONSUMER_SECRET));
i.putExtra(PrepareRequestTokenActivity.REQUEST_URL, Constants.REQUEST_URL);
i.putExtra(PrepareRequestTokenActivity.ACCESS_URL, Constants.ACCESS_URL);
i.putExtra(PrepareRequestTokenActivity.AUTHORIZE_URL, Constants.AUTHORIZE_URL);
this.startActivity(i);
}
}
public void startDownloadTask(Context context, ProgressListener listener, Pair<Integer, Integer> track)
{
new DownloadBreadcrumbsTrackTask(context, listener, this, mHttpClient, getOAuthConsumer(), track).executeOn(mExecutor);
}
public void startUploadTask(Context context, ProgressListener listener, Uri trackUri, String name)
{
new UploadBreadcrumbsTrackTask(context, this, listener, mHttpClient, getOAuthConsumer(), trackUri, name).executeOn(mExecutor);
}
public boolean isAuthorized()
{
return mAuthorized;
}
public void willDisplayItem(Pair<Integer, Integer> item)
{
if (item.first == Constants.BREADCRUMBS_BUNDLE_ITEM_VIEW_TYPE)
{
if (!mFinishing && !mTracks.areTracksLoaded(item) && !mTracks.areTracksLoadingScheduled(item))
{
new GetBreadcrumbsTracksTask(this, this, this, mHttpClient, getOAuthConsumer(), item.second).executeOn(mExecutor);
mTracks.addTracksLoadingScheduled(item);
}
}
}
public List<Pair<Integer, Integer>> getAllItems()
{
List<Pair<Integer, Integer>> items = mTracks.getAllItems();
return items;
}
public List<Pair<Integer, Integer>> getActivityList()
{
List<Pair<Integer, Integer>> activities = mTracks.getActivityList();
return activities;
}
public List<Pair<Integer, Integer>> getBundleList()
{
List<Pair<Integer, Integer>> bundles = mTracks.getBundleList();
return bundles;
}
public String getValueForItem(Pair<Integer, Integer> item, String name)
{
return mTracks.getValueForItem(item, name);
}
public void clearAllCache()
{
mTracks.clearAllCache(this);
}
protected BreadcrumbsTracks getBreadcrumbsTracks()
{
return mTracks;
}
public boolean isLocalTrackSynced(long trackId)
{
return mTracks.isLocalTrackSynced(trackId);
}
/****
* Observer interface
*/
@Override
public void update(Observable observable, Object data)
{
Intent broadcast = new Intent();
broadcast.setAction(BreadcrumbsService.NOTIFY_DATA_SET_CHANGED);
getApplicationContext().sendBroadcast(broadcast);
}
/****
* ProgressListener interface
*/
@Override
public void setIndeterminate(boolean indeterminate)
{
Intent broadcast = new Intent();
broadcast.putExtra(BreadcrumbsService.PROGRESS_INDETERMINATE, indeterminate);
broadcast.setAction(BreadcrumbsService.NOTIFY_PROGRESS_CHANGED);
getApplicationContext().sendBroadcast(broadcast);
}
@Override
public void started()
{
Intent broadcast = new Intent();
broadcast.putExtra(BreadcrumbsService.PROGRESS_STATE, BreadcrumbsService.PROGRESS_STARTED);
broadcast.setAction(BreadcrumbsService.NOTIFY_PROGRESS_CHANGED);
getApplicationContext().sendBroadcast(broadcast);
}
@Override
public void setProgress(int value)
{
Intent broadcast = new Intent();
broadcast.putExtra(BreadcrumbsService.PROGRESS, value);
broadcast.setAction(BreadcrumbsService.NOTIFY_PROGRESS_CHANGED);
getApplicationContext().sendBroadcast(broadcast);
}
@Override
public void finished(Uri result)
{
Intent broadcast = new Intent();
broadcast.putExtra(BreadcrumbsService.PROGRESS_STATE, BreadcrumbsService.PROGRESS_FINISHED);
broadcast.putExtra(BreadcrumbsService.PROGRESS_RESULT, result);
broadcast.setAction(BreadcrumbsService.NOTIFY_PROGRESS_CHANGED);
getApplicationContext().sendBroadcast(broadcast);
}
@Override
public void showError(String task, String errorMessage, Exception exception)
{
Intent broadcast = new Intent();
broadcast.putExtra(BreadcrumbsService.PROGRESS_STATE, BreadcrumbsService.PROGRESS_ERROR);
broadcast.putExtra(BreadcrumbsService.PROGRESS_TASK, task);
broadcast.putExtra(BreadcrumbsService.PROGRESS_MESSAGE, errorMessage);
broadcast.putExtra(BreadcrumbsService.PROGRESS_RESULT, exception);
broadcast.setAction(BreadcrumbsService.NOTIFY_PROGRESS_CHANGED);
getApplicationContext().sendBroadcast(broadcast);
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/breadcrumbs/BreadcrumbsService.java | Java | gpl3 | 12,931 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.breadcrumbs;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.tasks.GpxCreator;
import nl.sogeti.android.gpstracker.actions.tasks.XmlCreator;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.adapter.BreadcrumbsAdapter;
import nl.sogeti.android.gpstracker.db.GPStracking.MetaData;
import oauth.signpost.OAuthConsumer;
import oauth.signpost.exception.OAuthCommunicationException;
import oauth.signpost.exception.OAuthExpectationFailedException;
import oauth.signpost.exception.OAuthMessageSignerException;
import org.apache.ogt.http.Header;
import org.apache.ogt.http.HttpEntity;
import org.apache.ogt.http.HttpResponse;
import org.apache.ogt.http.client.HttpClient;
import org.apache.ogt.http.client.methods.HttpPost;
import org.apache.ogt.http.entity.mime.HttpMultipartMode;
import org.apache.ogt.http.entity.mime.MultipartEntity;
import org.apache.ogt.http.entity.mime.content.FileBody;
import org.apache.ogt.http.entity.mime.content.StringBody;
import org.apache.ogt.http.util.EntityUtils;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.util.Log;
/**
* An asynchronous task that communicates with Twitter to retrieve a request
* token. (OAuthGetRequestToken) After receiving the request token from Twitter,
* pop a browser to the user to authorize the Request Token.
* (OAuthAuthorizeToken)
*/
public class UploadBreadcrumbsTrackTask extends GpxCreator
{
final String TAG = "OGT.UploadBreadcrumbsTrackTask";
private BreadcrumbsService mService;
private OAuthConsumer mConsumer;
private HttpClient mHttpClient;
private String mActivityId;
private String mBundleId;
private String mDescription;
private String mIsPublic;
private String mBundleName;
private String mBundleDescription;
private boolean mIsBundleCreated;
private List<File> mPhotoUploadQueue;
/**
* Constructor: create a new UploadBreadcrumbsTrackTask.
*
* @param context
* @param adapter
* @param listener
* @param httpclient
* @param consumer
* @param trackUri
* @param name
*/
public UploadBreadcrumbsTrackTask(Context context, BreadcrumbsService adapter, ProgressListener listener, HttpClient httpclient, OAuthConsumer consumer,
Uri trackUri, String name)
{
super(context, trackUri, name, true, listener);
mService = adapter;
mHttpClient = httpclient;
mConsumer = consumer;
mPhotoUploadQueue = new LinkedList<File>();
}
/**
* Retrieve the OAuth Request Token and present a browser to the user to
* authorize the token.
*/
@Override
protected Uri doInBackground(Void... params)
{
// Leave room in the progressbar for uploading
determineProgressGoal();
mProgressAdmin.setUpload(true);
// Build GPX file
Uri gpxFile = exportGpx();
if (isCancelled())
{
String text = mContext.getString(R.string.ticker_failed) + " \"http://api.gobreadcrumbs.com/v1/tracks\" "
+ mContext.getString(R.string.error_buildxml);
handleError(mContext.getString(R.string.taskerror_breadcrumbs_upload), new IOException("Fail to execute request due to canceling"), text);
}
// Collect GPX Import option params
mActivityId = null;
mBundleId = null;
mDescription = null;
mIsPublic = null;
Uri metadataUri = Uri.withAppendedPath(mTrackUri, "metadata");
Cursor cursor = null;
try
{
cursor = mContext.getContentResolver().query(metadataUri, new String[] { MetaData.KEY, MetaData.VALUE }, null, null, null);
if (cursor.moveToFirst())
{
do
{
String key = cursor.getString(0);
if (BreadcrumbsTracks.ACTIVITY_ID.equals(key))
{
mActivityId = cursor.getString(1);
}
else if (BreadcrumbsTracks.BUNDLE_ID.equals(key))
{
mBundleId = cursor.getString(1);
}
else if (BreadcrumbsTracks.DESCRIPTION.equals(key))
{
mDescription = cursor.getString(1);
}
else if (BreadcrumbsTracks.ISPUBLIC.equals(key))
{
mIsPublic = cursor.getString(1);
}
}
while (cursor.moveToNext());
}
}
finally
{
if (cursor != null)
{
cursor.close();
}
}
if ("-1".equals(mActivityId))
{
String text = "Unable to upload without a activity id stored in meta-data table";
IllegalStateException e = new IllegalStateException(text);
handleError(mContext.getString(R.string.taskerror_breadcrumbs_upload), e, text);
}
int statusCode = 0;
String responseText = null;
Uri trackUri = null;
HttpEntity responseEntity = null;
try
{
if ("-1".equals(mBundleId))
{
mBundleDescription = "";//mContext.getString(R.string.breadcrumbs_bundledescription);
mBundleName = mContext.getString(R.string.app_name);
mBundleId = createOpenGpsTrackerBundle();
}
String gpxString = XmlCreator.convertStreamToString(mContext.getContentResolver().openInputStream(gpxFile));
HttpPost method = new HttpPost("http://api.gobreadcrumbs.com:80/v1/tracks");
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
// Build the multipart body with the upload data
MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
entity.addPart("import_type", new StringBody("GPX"));
//entity.addPart("gpx", new FileBody(gpxFile));
entity.addPart("gpx", new StringBody(gpxString));
entity.addPart("bundle_id", new StringBody(mBundleId));
entity.addPart("activity_id", new StringBody(mActivityId));
entity.addPart("description", new StringBody(mDescription));
// entity.addPart("difficulty", new StringBody("3"));
// entity.addPart("rating", new StringBody("4"));
entity.addPart("public", new StringBody(mIsPublic));
method.setEntity(entity);
// Execute the POST to OpenStreetMap
mConsumer.sign(method);
if( BreadcrumbsAdapter.DEBUG )
{
Log.d( TAG, "HTTP Method "+method.getMethod() );
Log.d( TAG, "URI scheme "+method.getURI().getScheme() );
Log.d( TAG, "Host name "+method.getURI().getHost() );
Log.d( TAG, "Port "+method.getURI().getPort() );
Log.d( TAG, "Request path "+method.getURI().getPath());
Log.d( TAG, "Consumer Key: "+mConsumer.getConsumerKey());
Log.d( TAG, "Consumer Secret: "+mConsumer.getConsumerSecret());
Log.d( TAG, "Token: "+mConsumer.getToken());
Log.d( TAG, "Token Secret: "+mConsumer.getTokenSecret());
Log.d( TAG, "Execute request: "+method.getURI() );
for( Header header : method.getAllHeaders() )
{
Log.d( TAG, " with header: "+header.toString());
}
}
HttpResponse response = mHttpClient.execute(method);
mProgressAdmin.addUploadProgress();
statusCode = response.getStatusLine().getStatusCode();
responseEntity = response.getEntity();
InputStream stream = responseEntity.getContent();
responseText = XmlCreator.convertStreamToString(stream);
if( BreadcrumbsAdapter.DEBUG )
{
Log.d( TAG, "Upload Response: "+responseText);
}
Pattern p = Pattern.compile(">([0-9]+)</id>");
Matcher m = p.matcher(responseText);
if (m.find())
{
Integer trackId = Integer.valueOf(m.group(1));
trackUri = Uri.parse("http://api.gobreadcrumbs.com/v1/tracks/" + trackId + "/placemarks.gpx");
for( File photo :mPhotoUploadQueue )
{
uploadPhoto(photo, trackId);
}
}
}
catch (OAuthMessageSignerException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_upload), e, "Failed to sign the request with authentication signature");
}
catch (OAuthExpectationFailedException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_upload), e, "The request did not authenticate");
}
catch (OAuthCommunicationException e)
{
mService.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_upload), e, "The authentication communication failed");
}
catch (IOException e)
{
handleError(mContext.getString(R.string.taskerror_breadcrumbs_upload), e, "A problem during communication");
}
finally
{
if (responseEntity != null)
{
try
{
EntityUtils.consume(responseEntity);
}
catch (IOException e)
{
Log.e(TAG, "Failed to close the content stream", e);
}
}
}
if (statusCode == 200 || statusCode == 201)
{
if (trackUri == null)
{
handleError(mContext.getString(R.string.taskerror_breadcrumbs_upload), new IOException("Unable to retrieve URI from response"), responseText);
}
}
else
{
//mAdapter.removeAuthentication();
handleError(mContext.getString(R.string.taskerror_breadcrumbs_upload), new IOException("Status code: " + statusCode), responseText);
}
return trackUri;
}
private String createOpenGpsTrackerBundle() throws OAuthMessageSignerException, OAuthExpectationFailedException,
OAuthCommunicationException, IOException
{
HttpPost method = new HttpPost("http://api.gobreadcrumbs.com/v1/bundles.xml");
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
entity.addPart("name", new StringBody(mBundleName));
entity.addPart("activity_id", new StringBody(mActivityId));
entity.addPart("description", new StringBody(mBundleDescription));
method.setEntity(entity);
mConsumer.sign(method);
HttpResponse response = mHttpClient.execute(method);
HttpEntity responseEntity = response.getEntity();
InputStream stream = responseEntity.getContent();
String responseText = XmlCreator.convertStreamToString(stream);
Pattern p = Pattern.compile(">([0-9]+)</id>");
Matcher m = p.matcher(responseText);
String bundleId = null;
if (m.find())
{
bundleId = m.group(1);
ContentValues values = new ContentValues();
values.put(MetaData.KEY, BreadcrumbsTracks.BUNDLE_ID);
values.put(MetaData.VALUE, bundleId);
Uri metadataUri = Uri.withAppendedPath(mTrackUri, "metadata");
mContext.getContentResolver().insert(metadataUri, values);
mIsBundleCreated = true;
}
else
{
String text = "Unable to upload (yet) without a bunld id stored in meta-data table";
IllegalStateException e = new IllegalStateException(text);
handleError(mContext.getString(R.string.taskerror_breadcrumbs_upload), e, text);
}
return bundleId;
}
/**
* Queue's media
*
* @param inputFilePath
* @return file path relative to the export dir
* @throws IOException
*/
@Override
protected String includeMediaFile(String inputFilePath) throws IOException
{
File source = new File(inputFilePath);
if (source.exists())
{
mProgressAdmin.setPhotoUpload(source.length());
mPhotoUploadQueue.add(source);
}
return source.getName();
}
private void uploadPhoto(File photo, Integer trackId) throws IOException, OAuthMessageSignerException, OAuthExpectationFailedException, OAuthCommunicationException
{
HttpPost request = new HttpPost("http://api.gobreadcrumbs.com/v1/photos.xml");
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
entity.addPart("name", new StringBody(photo.getName()));
entity.addPart("track_id", new StringBody(Integer.toString(trackId)));
//entity.addPart("description", new StringBody(""));
entity.addPart("file", new FileBody(photo));
request.setEntity(entity);
mConsumer.sign(request);
if( BreadcrumbsAdapter.DEBUG )
{
Log.d( TAG, "Execute request: "+request.getURI() );
for( Header header : request.getAllHeaders() )
{
Log.d( TAG, " with header: "+header.toString());
}
}
HttpResponse response = mHttpClient.execute(request);
HttpEntity responseEntity = response.getEntity();
InputStream stream = responseEntity.getContent();
String responseText = XmlCreator.convertStreamToString(stream);
mProgressAdmin.addPhotoUploadProgress(photo.length());
Log.i( TAG, "Uploaded photo "+responseText);
}
@Override
protected void onPostExecute(Uri result)
{
BreadcrumbsTracks tracks = mService.getBreadcrumbsTracks();
Uri metadataUri = Uri.withAppendedPath(mTrackUri, "metadata");
List<String> segments = result.getPathSegments();
Integer bcTrackId = Integer.valueOf(segments.get(segments.size() - 2));
ArrayList<ContentValues> metaValues = new ArrayList<ContentValues>();
metaValues.add(buildContentValues(BreadcrumbsTracks.TRACK_ID, Long.toString(bcTrackId)));
if (mDescription != null)
{
metaValues.add(buildContentValues(BreadcrumbsTracks.DESCRIPTION, mDescription));
}
if (mIsPublic != null)
{
metaValues.add(buildContentValues(BreadcrumbsTracks.ISPUBLIC, mIsPublic));
}
metaValues.add(buildContentValues(BreadcrumbsTracks.BUNDLE_ID, mBundleId));
metaValues.add(buildContentValues(BreadcrumbsTracks.ACTIVITY_ID, mActivityId));
// Store in OGT provider
ContentResolver resolver = mContext.getContentResolver();
resolver.bulkInsert(metadataUri, metaValues.toArray(new ContentValues[1]));
// Store in Breadcrumbs adapter
tracks.addSyncedTrack(Long.valueOf(mTrackUri.getLastPathSegment()), bcTrackId);
if( mIsBundleCreated )
{
mService.getBreadcrumbsTracks().addBundle(Integer.parseInt(mBundleId), mBundleName, mBundleDescription);
}
//"http://api.gobreadcrumbs.com/v1/tracks/" + trackId + "/placemarks.gpx"
mService.getBreadcrumbsTracks().addTrack(bcTrackId, mName, Integer.valueOf(mBundleId), mDescription, null, null, null, mIsPublic, null, null, null, null, null);
super.onPostExecute(result);
}
private ContentValues buildContentValues(String key, String value)
{
ContentValues contentValues = new ContentValues();
contentValues.put(MetaData.KEY, key);
contentValues.put(MetaData.VALUE, value);
return contentValues;
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/breadcrumbs/UploadBreadcrumbsTrackTask.java | Java | gpl3 | 17,596 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) May 29, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.breadcrumbs;
import java.util.concurrent.Executor;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import android.annotation.TargetApi;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Build;
import android.util.Log;
/**
* ????
*
* @version $Id:$
* @author rene (c) May 29, 2011, Sogeti B.V.
*/
public abstract class BreadcrumbsTask extends AsyncTask<Void, Void, Void>
{
private static final String TAG = "OGT.BreadcrumbsTask";
private ProgressListener mListener;
private String mErrorText;
private Exception mException;
protected BreadcrumbsService mService;
private String mTask;
protected Context mContext;
public BreadcrumbsTask(Context context, BreadcrumbsService adapter, ProgressListener listener)
{
mContext = context;
mListener = listener;
mService = adapter;
}
@TargetApi(11)
public void executeOn(Executor executor)
{
if (Build.VERSION.SDK_INT >= 11)
{
executeOnExecutor(executor);
}
else
{
execute();
}
}
protected void handleError(String task, Exception e, String text)
{
Log.e(TAG, "Received error will cancel background task " + this.getClass().getName(), e);
mService.removeAuthentication();
mTask = task;
mException = e;
mErrorText = text;
cancel(true);
}
@Override
protected void onPreExecute()
{
if (mListener != null)
{
mListener.setIndeterminate(true);
mListener.started();
}
}
@Override
protected void onPostExecute(Void result)
{
this.updateTracksData(mService.getBreadcrumbsTracks());
if (mListener != null)
{
mListener.finished(null);
}
}
protected abstract void updateTracksData(BreadcrumbsTracks tracks);
@Override
protected void onCancelled()
{
if (mListener != null)
{
mListener.finished(null);
}
if (mListener != null && mErrorText != null && mException != null)
{
mListener.showError(mTask, mErrorText, mException);
}
else if (mException != null)
{
Log.e(TAG, "Incomplete error after cancellation:" + mErrorText, mException);
}
else
{
Log.e(TAG, "Incomplete error after cancellation:" + mErrorText);
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/breadcrumbs/BreadcrumbsTask.java | Java | gpl3 | 3,932 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.breadcrumbs;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.tasks.GpxParser;
import nl.sogeti.android.gpstracker.actions.tasks.XmlCreator;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.adapter.BreadcrumbsAdapter;
import nl.sogeti.android.gpstracker.db.GPStracking.MetaData;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.util.Pair;
import oauth.signpost.OAuthConsumer;
import oauth.signpost.exception.OAuthCommunicationException;
import oauth.signpost.exception.OAuthExpectationFailedException;
import oauth.signpost.exception.OAuthMessageSignerException;
import org.apache.ogt.http.Header;
import org.apache.ogt.http.HttpEntity;
import org.apache.ogt.http.HttpResponse;
import org.apache.ogt.http.client.methods.HttpGet;
import org.apache.ogt.http.client.methods.HttpUriRequest;
import org.apache.ogt.http.impl.client.DefaultHttpClient;
import org.apache.ogt.http.util.EntityUtils;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.net.Uri;
import android.util.Log;
/**
* An asynchronous task that communicates with Twitter to retrieve a request
* token. (OAuthGetRequestToken) After receiving the request token from Twitter,
* pop a browser to the user to authorize the Request Token.
* (OAuthAuthorizeToken)
*/
public class DownloadBreadcrumbsTrackTask extends GpxParser
{
final String TAG = "OGT.GetBreadcrumbsTracksTask";
private BreadcrumbsService mAdapter;
private OAuthConsumer mConsumer;
private DefaultHttpClient mHttpclient;
private Pair<Integer, Integer> mTrack;
/**
*
* Constructor: create a new DownloadBreadcrumbsTrackTask.
* @param context
* @param progressListener
* @param adapter
* @param httpclient
* @param consumer
* @param track
*/
public DownloadBreadcrumbsTrackTask(Context context, ProgressListener progressListener, BreadcrumbsService adapter, DefaultHttpClient httpclient,
OAuthConsumer consumer, Pair<Integer, Integer> track)
{
super(context, progressListener);
mAdapter = adapter;
mHttpclient = httpclient;
mConsumer = consumer;
mTrack = track;
}
/**
* Retrieve the OAuth Request Token and present a browser to the user to
* authorize the token.
*/
@Override
protected Uri doInBackground(Uri... params)
{
determineProgressGoal(null);
Uri trackUri = null;
String trackName = mAdapter.getBreadcrumbsTracks().getValueForItem(mTrack, BreadcrumbsTracks.NAME);
HttpEntity responseEntity = null;
try
{
HttpUriRequest request = new HttpGet("http://api.gobreadcrumbs.com/v1/tracks/" + mTrack.second + "/placemarks.gpx");
if (isCancelled())
{
throw new IOException("Fail to execute request due to canceling");
}
mConsumer.sign(request);
if( BreadcrumbsAdapter.DEBUG )
{
Log.d( TAG, "Execute request: "+request.getURI() );
for( Header header : request.getAllHeaders() )
{
Log.d( TAG, " with header: "+header.toString());
}
}
HttpResponse response = mHttpclient.execute(request);
responseEntity = response.getEntity();
InputStream is = responseEntity.getContent();
InputStream stream = new BufferedInputStream(is, 8192);
if( BreadcrumbsAdapter.DEBUG )
{
stream = XmlCreator.convertStreamToLoggedStream(TAG, stream);
}
trackUri = importTrack(stream, trackName);
}
catch (OAuthMessageSignerException e)
{
handleError(e, mContext.getString(R.string.error_importgpx_xml));
}
catch (OAuthExpectationFailedException e)
{
handleError(e, mContext.getString(R.string.error_importgpx_xml));
}
catch (OAuthCommunicationException e)
{
handleError(e, mContext.getString(R.string.error_importgpx_xml));
}
catch (IOException e)
{
handleError(e, mContext.getString(R.string.error_importgpx_xml));
}
finally
{
if (responseEntity != null)
{
try
{
EntityUtils.consume(responseEntity);
}
catch (IOException e)
{
Log.e( TAG, "Failed to close the content stream", e);
}
}
}
return trackUri;
}
@Override
protected void onPostExecute(Uri result)
{
super.onPostExecute(result);
long ogtTrackId = Long.parseLong(result.getLastPathSegment());
Uri metadataUri = Uri.withAppendedPath(ContentUris.withAppendedId(Tracks.CONTENT_URI, ogtTrackId), "metadata");
BreadcrumbsTracks tracks = mAdapter.getBreadcrumbsTracks();
Integer bcTrackId = mTrack.second;
Integer bcBundleId = tracks.getBundleIdForTrackId(bcTrackId);
//TODO Integer bcActivityId = tracks.getActivityIdForBundleId(bcBundleId);
String bcDifficulty = tracks.getValueForItem(mTrack, BreadcrumbsTracks.DIFFICULTY);
String bcRating = tracks.getValueForItem(mTrack, BreadcrumbsTracks.RATING);
String bcPublic = tracks.getValueForItem(mTrack, BreadcrumbsTracks.ISPUBLIC);
String bcDescription = tracks.getValueForItem(mTrack, BreadcrumbsTracks.DESCRIPTION);
ArrayList<ContentValues> metaValues = new ArrayList<ContentValues>();
if (bcTrackId != null)
{
metaValues.add(buildContentValues(BreadcrumbsTracks.TRACK_ID, Long.toString(bcTrackId)));
}
if (bcDescription != null)
{
metaValues.add(buildContentValues(BreadcrumbsTracks.DESCRIPTION, bcDescription));
}
if (bcDifficulty != null)
{
metaValues.add(buildContentValues(BreadcrumbsTracks.DIFFICULTY, bcDifficulty));
}
if (bcRating != null)
{
metaValues.add(buildContentValues(BreadcrumbsTracks.RATING, bcRating));
}
if (bcPublic != null)
{
metaValues.add(buildContentValues(BreadcrumbsTracks.ISPUBLIC, bcPublic));
}
if (bcBundleId != null)
{
metaValues.add(buildContentValues(BreadcrumbsTracks.BUNDLE_ID, Integer.toString(bcBundleId)));
}
// if (bcActivityId != null)
// {
// metaValues.add(buildContentValues(BreadcrumbsTracks.ACTIVITY_ID, Integer.toString(bcActivityId)));
// }
ContentResolver resolver = mContext.getContentResolver();
resolver.bulkInsert(metadataUri, metaValues.toArray(new ContentValues[1]));
tracks.addSyncedTrack(ogtTrackId, mTrack.second);
}
private ContentValues buildContentValues(String key, String value)
{
ContentValues contentValues = new ContentValues();
contentValues.put(MetaData.KEY, key);
contentValues.put(MetaData.VALUE, value);
return contentValues;
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/breadcrumbs/DownloadBreadcrumbsTrackTask.java | Java | gpl3 | 8,737 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.oauth;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.util.Constants;
import oauth.signpost.OAuthConsumer;
import oauth.signpost.OAuthProvider;
import oauth.signpost.commonshttp.CommonsHttpOAuthConsumer;
import oauth.signpost.commonshttp.CommonsHttpOAuthProvider;
import android.app.Activity;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.Uri;
import android.os.AsyncTask.Status;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.util.Log;
import android.widget.TextView;
/**
* Prepares a OAuthConsumer and OAuthProvider OAuthConsumer is configured with
* the consumer key & consumer secret. Both key and secret are retrieved from
* the extras in the Intent
*
* OAuthProvider is configured with the 3
* OAuth endpoints. These are retrieved from the extras in the Intent.
*
* Execute the OAuthRequestTokenTask to retrieve the request,
* and authorize the request. After the request is authorized, a callback is
* made here and this activity finishes to return to the last Activity on the
* stack.
*/
public class PrepareRequestTokenActivity extends Activity
{
/**
* Name of the Extra in the intent holding the consumer secret
*/
public static final String CONSUMER_SECRET = "CONSUMER_SECRET";
/**
* Name of the Extra in the intent holding the consumer key
*/
public static final String CONSUMER_KEY = "CONSUMER_KEY";
/**
* Name of the Extra in the intent holding the authorizationWebsiteUrl
*/
public static final String AUTHORIZE_URL = "AUTHORIZE_URL";
/**
* Name of the Extra in the intent holding the accessTokenEndpointUrl
*/
public static final String ACCESS_URL = "ACCESS_URL";
/**
* Name of the Extra in the intent holding the requestTokenEndpointUrl
*/
public static final String REQUEST_URL = "REQUEST_URL";
/**
* String value of the key in the DefaultSharedPreferences
* in which to store the permission token
*/
public static final String OAUTH_TOKEN_PREF = "OAUTH_TOKEN";
/**
* String value of the key in the DefaultSharedPreferences
* in which to store the permission secret
*/
public static final String OAUTH_TOKEN_SECRET_PREF = "OAUTH_TOKEN_SECRET";
final String TAG = "OGT.PrepareRequestTokenActivity";
private OAuthConsumer consumer;
private OAuthProvider provider;
private String mTokenKey;
private String mSecretKey;
private OAuthRequestTokenTask mTask;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.oauthentication);
String key = getIntent().getStringExtra(CONSUMER_KEY);
String secret = getIntent().getStringExtra(CONSUMER_SECRET);
String requestUrl = getIntent().getStringExtra(REQUEST_URL);
String accessUrl = getIntent().getStringExtra(ACCESS_URL);
String authUrl = getIntent().getStringExtra(AUTHORIZE_URL);
TextView tv = (TextView) findViewById(R.id.detail);
tv.setText(requestUrl);
mTokenKey = getIntent().getStringExtra(OAUTH_TOKEN_PREF);
mSecretKey = getIntent().getStringExtra(OAUTH_TOKEN_SECRET_PREF);
this.consumer = new CommonsHttpOAuthConsumer(key, secret);
this.provider = new CommonsHttpOAuthProvider(requestUrl, accessUrl, authUrl);
mTask = new OAuthRequestTokenTask(this, consumer, provider);
mTask.execute();
}
@Override
protected void onResume()
{
super.onResume();
// Will not be called if onNewIntent() was called with callback scheme
Status status = mTask.getStatus();
if( status != Status.RUNNING )
{
finish();
}
}
/**
* Called when the OAuthRequestTokenTask finishes (user has authorized the
* request token). The callback URL will be intercepted here.
*/
@Override
public void onNewIntent(Intent intent)
{
super.onNewIntent(intent);
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
final Uri uri = intent.getData();
if (uri != null && uri.getScheme().equals(Constants.OAUTH_CALLBACK_SCHEME))
{
Log.i(TAG, "Callback received : " + uri);
Log.i(TAG, "Retrieving Access Token");
new RetrieveAccessTokenTask(this, consumer, provider, prefs, mTokenKey, mSecretKey).execute(uri);
finish();
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/oauth/PrepareRequestTokenActivity.java | Java | gpl3 | 6,091 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.oauth;
import oauth.signpost.OAuth;
import oauth.signpost.OAuthConsumer;
import oauth.signpost.OAuthProvider;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.net.Uri;
import android.os.AsyncTask;
import android.util.Log;
public class RetrieveAccessTokenTask extends AsyncTask<Uri, Void, Void>
{
private static final String TAG = "OGT.RetrieveAccessTokenTask";
private OAuthProvider provider;
private OAuthConsumer consumer;
private SharedPreferences prefs;
private String mTokenKey;
private String mSecretKey;
public RetrieveAccessTokenTask(Context context, OAuthConsumer consumer, OAuthProvider provider, SharedPreferences prefs, String tokenKey, String secretKey)
{
this.consumer = consumer;
this.provider = provider;
this.prefs = prefs;
mTokenKey = tokenKey;
mSecretKey = secretKey;
}
/**
* Retrieve the oauth_verifier, and store the oauth and oauth_token_secret
* for future API calls.
*/
@Override
protected Void doInBackground(Uri... params)
{
final Uri uri = params[0];
final String oauth_verifier = uri.getQueryParameter(OAuth.OAUTH_VERIFIER);
try
{
provider.retrieveAccessToken(consumer, oauth_verifier);
final Editor edit = prefs.edit();
edit.putString(mTokenKey, consumer.getToken());
edit.putString(mSecretKey, consumer.getTokenSecret());
edit.commit();
Log.i(TAG, "OAuth - Access Token Retrieved and stored to "+mTokenKey+" and "+mSecretKey);
}
catch (Exception e)
{
Log.e(TAG, "OAuth - Access Token Retrieval Error", e);
}
return null;
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/oauth/RetrieveAccessTokenTask.java | Java | gpl3 | 3,310 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.oauth;
import nl.sogeti.android.gpstracker.util.Constants;
import oauth.signpost.OAuthConsumer;
import oauth.signpost.OAuthProvider;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.AsyncTask;
import android.util.Log;
/**
* An asynchronous task that communicates with Twitter to retrieve a request
* token. (OAuthGetRequestToken) After receiving the request token from Twitter,
* pop a browser to the user to authorize the Request Token.
* (OAuthAuthorizeToken)
*/
public class OAuthRequestTokenTask extends AsyncTask<Void, Void, Void>
{
final String TAG = "OGT.OAuthRequestTokenTask";
private Context context;
private OAuthProvider provider;
private OAuthConsumer consumer;
/**
* We pass the OAuth consumer and provider.
*
* @param context Required to be able to start the intent to launch the
* browser.
* @param provider The OAuthProvider object
* @param consumer The OAuthConsumer object
*/
public OAuthRequestTokenTask(Context context, OAuthConsumer consumer, OAuthProvider provider)
{
this.context = context;
this.consumer = consumer;
this.provider = provider;
}
/**
* Retrieve the OAuth Request Token and present a browser to the user to
* authorize the token.
*/
@Override
protected Void doInBackground(Void... params)
{
try
{
final String url = provider.retrieveRequestToken(consumer, Constants.OAUTH_CALLBACK_URL);
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_NO_HISTORY | Intent.FLAG_FROM_BACKGROUND);
context.startActivity(intent);
}
catch (Exception e)
{
Log.e(TAG, "Failed to start token request ", e);
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(Constants.OAUTH_CALLBACK_URL));
intent.putExtra("ERROR", e.toString());
context.startActivity(intent);
}
return null;
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/oauth/OAuthRequestTokenTask.java | Java | gpl3 | 3,633 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.widget;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.ControlTracking;
import nl.sogeti.android.gpstracker.actions.InsertNote;
import nl.sogeti.android.gpstracker.util.Constants;
import android.app.PendingIntent;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.util.Log;
import android.view.View;
import android.widget.RemoteViews;
/**
* An App Widget for on the home screen to control logging with a start, pause,
* resume and stop
*
* @version $Id$
* @author grootren (c) Mar 8, 2011, Sogeti B.V.
*/
public class ControlWidgetProvider extends AppWidgetProvider
{
private static final int BUTTON_TRACKINGCONTROL = 2;
private static final int BUTTON_INSERTNOTE = 3;
private static final String TAG = "OGT.ControlWidgetProvider";
static final ComponentName THIS_APPWIDGET = new ComponentName("nl.sogeti.android.gpstracker", "nl.sogeti.android.gpstracker.widget.ControlWidgetProvider");
private static int mState;
public ControlWidgetProvider()
{
super();
}
@Override
public void onEnabled(Context context)
{
// Log.d(TAG, "onEnabled() ");
super.onEnabled(context);
context.startService(new Intent(Constants.SERVICENAME));
}
@Override
public void onDisabled(Context context)
{
// Log.d(TAG, "onDisabled() ");
}
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds)
{
// Log.d(TAG, "onDisabled() ");
// Update each requested appWidgetId
RemoteViews view = buildUpdate(context, -1);
for (int i = 0; i < appWidgetIds.length; i++)
{
appWidgetManager.updateAppWidget(appWidgetIds[i], view);
}
}
/**
* Load image for given widget and build {@link RemoteViews} for it.
*/
static RemoteViews buildUpdate(Context context, int appWidgetId)
{
RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.control_appwidget);
views.setOnClickPendingIntent(R.id.widget_insertnote_enabled, getLaunchPendingIntent(context, appWidgetId, BUTTON_INSERTNOTE));
views.setOnClickPendingIntent(R.id.widget_trackingcontrol, getLaunchPendingIntent(context, appWidgetId, BUTTON_TRACKINGCONTROL));
updateButtons(views, context);
return views;
}
/**
* Load image for given widget and build {@link RemoteViews} for it.
*/
private static void updateButtons(RemoteViews views, Context context)
{
// Log.d(TAG, "Updated the remote views to state " + mState);
switch (mState)
{
case Constants.LOGGING:
setEnableInsertNote(views, true);
break;
case Constants.PAUSED:
setEnableInsertNote(views, false);
break;
case Constants.STOPPED:
setEnableInsertNote(views, false);
break;
case Constants.UNKNOWN:
setEnableInsertNote(views, false);
break;
default:
Log.w(TAG, "Unknown logging state for widget: " + mState);
break;
}
}
private static void setEnableInsertNote( RemoteViews views, boolean enabled )
{
if( enabled )
{
views.setViewVisibility(R.id.widget_insertnote_enabled, View.VISIBLE);
views.setViewVisibility(R.id.widget_insertnote_disabled, View.GONE);
}
else
{
views.setViewVisibility(R.id.widget_insertnote_enabled, View.GONE);
views.setViewVisibility(R.id.widget_insertnote_disabled, View.VISIBLE);
}
}
/**
* Creates PendingIntent to notify the widget of a button click.
*
* @param context
* @param appWidgetId
* @return
*/
private static PendingIntent getLaunchPendingIntent(Context context, int appWidgetId, int buttonId)
{
Intent launchIntent = new Intent();
launchIntent.setClass(context, ControlWidgetProvider.class);
launchIntent.addCategory(Intent.CATEGORY_ALTERNATIVE);
launchIntent.setData(Uri.parse("custom:" + buttonId));
PendingIntent pi = PendingIntent.getBroadcast(context, 0 /* no requestCode */, launchIntent, 0 /*
* no
* flags
*/);
return pi;
}
/**
* Receives and processes a button pressed intent or state change.
*
* @param context
* @param intent Indicates the pressed button.
*/
@Override
public void onReceive(Context context, Intent intent)
{
// Log.d(TAG, "Did recieve intent with action: " + intent.getAction());
super.onReceive(context, intent);
String action = intent.getAction();
if (Constants.LOGGING_STATE_CHANGED_ACTION.equals(action))
{
mState = intent.getIntExtra(Constants.EXTRA_LOGGING_STATE, Constants.UNKNOWN);
updateWidget(context);
}
else if (intent.hasCategory(Intent.CATEGORY_ALTERNATIVE))
{
Uri data = intent.getData();
int buttonId = Integer.parseInt(data.getSchemeSpecificPart());
if (buttonId == BUTTON_TRACKINGCONTROL)
{
Intent controlIntent = new Intent( context, ControlTracking.class );
controlIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(controlIntent);
}
else if (buttonId == BUTTON_INSERTNOTE)
{
Intent noteIntent = new Intent( context, InsertNote.class );
noteIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity( noteIntent );
}
}
else
{
// Don't fall-through to updating the widget. The Intent
// was something unrelated or that our super class took
// care of.
return;
}
// State changes fall through
updateWidget(context);
}
/**
* Updates the widget when something changes, or when a button is pushed.
*
* @param context
*/
public static void updateWidget(Context context)
{
RemoteViews views = buildUpdate(context, -1);
// Update specific list of appWidgetIds if given, otherwise default to all
final AppWidgetManager gm = AppWidgetManager.getInstance(context);
gm.updateAppWidget(THIS_APPWIDGET, views);
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/widget/ControlWidgetProvider.java | Java | gpl3 | 8,262 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.db;
import android.content.ContentUris;
import android.net.Uri;
import android.net.Uri.Builder;
import android.provider.BaseColumns;
/**
* The GPStracking provider stores all static information about GPStracking.
*
* @version $Id$
* @author rene (c) Jan 22, 2009, Sogeti B.V.
*/
public final class GPStracking
{
/** The authority of this provider: nl.sogeti.android.gpstracker */
public static final String AUTHORITY = "nl.sogeti.android.gpstracker";
/** The content:// style Uri for this provider, content://nl.sogeti.android.gpstracker */
public static final Uri CONTENT_URI = Uri.parse( "content://" + GPStracking.AUTHORITY );
/** The name of the database file */
static final String DATABASE_NAME = "GPSLOG.db";
/** The version of the database schema */
static final int DATABASE_VERSION = 10;
/**
* This table contains tracks.
*
* @author rene
*/
public static final class Tracks extends TracksColumns implements android.provider.BaseColumns
{
/** The MIME type of a CONTENT_URI subdirectory of a single track. */
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.nl.sogeti.android.track";
/** The MIME type of CONTENT_URI providing a directory of tracks. */
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.nl.sogeti.android.track";
/** The content:// style URL for this provider, content://nl.sogeti.android.gpstracker/tracks */
public static final Uri CONTENT_URI = Uri.parse( "content://" + GPStracking.AUTHORITY + "/" + Tracks.TABLE );
/** The name of this table */
public static final String TABLE = "tracks";
static final String CREATE_STATEMENT =
"CREATE TABLE " + Tracks.TABLE + "(" + " " + Tracks._ID + " " + Tracks._ID_TYPE +
"," + " " + Tracks.NAME + " " + Tracks.NAME_TYPE +
"," + " " + Tracks.CREATION_TIME + " " + Tracks.CREATION_TIME_TYPE +
");";
}
/**
* This table contains segments.
*
* @author rene
*/
public static final class Segments extends SegmentsColumns implements android.provider.BaseColumns
{
/** The MIME type of a CONTENT_URI subdirectory of a single segment. */
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.nl.sogeti.android.segment";
/** The MIME type of CONTENT_URI providing a directory of segments. */
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.nl.sogeti.android.segment";
/** The name of this table, segments */
public static final String TABLE = "segments";
static final String CREATE_STATMENT =
"CREATE TABLE " + Segments.TABLE + "(" + " " + Segments._ID + " " + Segments._ID_TYPE +
"," + " " + Segments.TRACK + " " + Segments.TRACK_TYPE +
");";
}
/**
* This table contains waypoints.
*
* @author rene
*/
public static final class Waypoints extends WaypointsColumns implements android.provider.BaseColumns
{
/** The MIME type of a CONTENT_URI subdirectory of a single waypoint. */
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.nl.sogeti.android.waypoint";
/** The MIME type of CONTENT_URI providing a directory of waypoints. */
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.nl.sogeti.android.waypoint";
/** The name of this table, waypoints */
public static final String TABLE = "waypoints";
static final String CREATE_STATEMENT = "CREATE TABLE " + Waypoints.TABLE +
"(" + " " + BaseColumns._ID + " " + WaypointsColumns._ID_TYPE +
"," + " " + WaypointsColumns.LATITUDE + " " + WaypointsColumns.LATITUDE_TYPE +
"," + " " + WaypointsColumns.LONGITUDE + " " + WaypointsColumns.LONGITUDE_TYPE +
"," + " " + WaypointsColumns.TIME + " " + WaypointsColumns.TIME_TYPE +
"," + " " + WaypointsColumns.SPEED + " " + WaypointsColumns.SPEED +
"," + " " + WaypointsColumns.SEGMENT + " " + WaypointsColumns.SEGMENT_TYPE +
"," + " " + WaypointsColumns.ACCURACY + " " + WaypointsColumns.ACCURACY_TYPE +
"," + " " + WaypointsColumns.ALTITUDE + " " + WaypointsColumns.ALTITUDE_TYPE +
"," + " " + WaypointsColumns.BEARING + " " + WaypointsColumns.BEARING_TYPE +
");";
static final String[] UPGRADE_STATEMENT_7_TO_8 =
{
"ALTER TABLE " + Waypoints.TABLE + " ADD COLUMN " + WaypointsColumns.ACCURACY + " " + WaypointsColumns.ACCURACY_TYPE +";",
"ALTER TABLE " + Waypoints.TABLE + " ADD COLUMN " + WaypointsColumns.ALTITUDE + " " + WaypointsColumns.ALTITUDE_TYPE +";",
"ALTER TABLE " + Waypoints.TABLE + " ADD COLUMN " + WaypointsColumns.BEARING + " " + WaypointsColumns.BEARING_TYPE +";"
};
/**
* Build a waypoint Uri like:
* content://nl.sogeti.android.gpstracker/tracks/2/segments/1/waypoints/52
* using the provided identifiers
*
* @param trackId
* @param segmentId
* @param waypointId
*
* @return
*/
public static Uri buildUri(long trackId, long segmentId, long waypointId)
{
Builder builder = Tracks.CONTENT_URI.buildUpon();
ContentUris.appendId(builder, trackId);
builder.appendPath(Segments.TABLE);
ContentUris.appendId(builder, segmentId);
builder.appendPath(Waypoints.TABLE);
ContentUris.appendId(builder, waypointId);
return builder.build();
}
}
/**
* This table contains media URI's.
*
* @author rene
*/
public static final class Media extends MediaColumns implements android.provider.BaseColumns
{
/** The MIME type of a CONTENT_URI subdirectory of a single media entry. */
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.nl.sogeti.android.media";
/** The MIME type of CONTENT_URI providing a directory of media entry. */
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.nl.sogeti.android.media";
/** The name of this table */
public static final String TABLE = "media";
static final String CREATE_STATEMENT = "CREATE TABLE " + Media.TABLE +
"(" + " " + BaseColumns._ID + " " + MediaColumns._ID_TYPE +
"," + " " + MediaColumns.TRACK + " " + MediaColumns.TRACK_TYPE +
"," + " " + MediaColumns.SEGMENT + " " + MediaColumns.SEGMENT_TYPE +
"," + " " + MediaColumns.WAYPOINT + " " + MediaColumns.WAYPOINT_TYPE +
"," + " " + MediaColumns.URI + " " + MediaColumns.URI_TYPE +
");";
public static final Uri CONTENT_URI = Uri.parse( "content://" + GPStracking.AUTHORITY + "/" + Media.TABLE );
}
/**
* This table contains media URI's.
*
* @author rene
*/
public static final class MetaData extends MetaDataColumns implements android.provider.BaseColumns
{
/** The MIME type of a CONTENT_URI subdirectory of a single metadata entry. */
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.nl.sogeti.android.metadata";
/** The MIME type of CONTENT_URI providing a directory of media entry. */
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.nl.sogeti.android.metadata";
/** The name of this table */
public static final String TABLE = "metadata";
static final String CREATE_STATEMENT = "CREATE TABLE " + MetaData.TABLE +
"(" + " " + BaseColumns._ID + " " + MetaDataColumns._ID_TYPE +
"," + " " + MetaDataColumns.TRACK + " " + MetaDataColumns.TRACK_TYPE +
"," + " " + MetaDataColumns.SEGMENT + " " + MetaDataColumns.SEGMENT_TYPE +
"," + " " + MetaDataColumns.WAYPOINT + " " + MetaDataColumns.WAYPOINT_TYPE +
"," + " " + MetaDataColumns.KEY + " " + MetaDataColumns.KEY_TYPE +
"," + " " + MetaDataColumns.VALUE + " " + MetaDataColumns.VALUE_TYPE +
");";
/**
* content://nl.sogeti.android.gpstracker/metadata
*/
public static final Uri CONTENT_URI = Uri.parse( "content://" + GPStracking.AUTHORITY + "/" + MetaData.TABLE );
}
/**
* Columns from the tracks table.
*
* @author rene
*/
public static class TracksColumns
{
public static final String NAME = "name";
public static final String CREATION_TIME = "creationtime";
static final String CREATION_TIME_TYPE = "INTEGER NOT NULL";
static final String NAME_TYPE = "TEXT";
static final String _ID_TYPE = "INTEGER PRIMARY KEY AUTOINCREMENT";
}
/**
* Columns from the segments table.
*
* @author rene
*/
public static class SegmentsColumns
{
/** The track _id to which this segment belongs */
public static final String TRACK = "track";
static final String TRACK_TYPE = "INTEGER NOT NULL";
static final String _ID_TYPE = "INTEGER PRIMARY KEY AUTOINCREMENT";
}
/**
* Columns from the waypoints table.
*
* @author rene
*/
public static class WaypointsColumns
{
/** The latitude */
public static final String LATITUDE = "latitude";
/** The longitude */
public static final String LONGITUDE = "longitude";
/** The recorded time */
public static final String TIME = "time";
/** The speed in meters per second */
public static final String SPEED = "speed";
/** The segment _id to which this segment belongs */
public static final String SEGMENT = "tracksegment";
/** The accuracy of the fix */
public static final String ACCURACY = "accuracy";
/** The altitude */
public static final String ALTITUDE = "altitude";
/** the bearing of the fix */
public static final String BEARING = "bearing";
static final String LATITUDE_TYPE = "REAL NOT NULL";
static final String LONGITUDE_TYPE = "REAL NOT NULL";
static final String TIME_TYPE = "INTEGER NOT NULL";
static final String SPEED_TYPE = "REAL NOT NULL";
static final String SEGMENT_TYPE = "INTEGER NOT NULL";
static final String ACCURACY_TYPE = "REAL";
static final String ALTITUDE_TYPE = "REAL";
static final String BEARING_TYPE = "REAL";
static final String _ID_TYPE = "INTEGER PRIMARY KEY AUTOINCREMENT";
}
/**
* Columns from the media table.
*
* @author rene
*/
public static class MediaColumns
{
/** The track _id to which this segment belongs */
public static final String TRACK = "track";
static final String TRACK_TYPE = "INTEGER NOT NULL";
public static final String SEGMENT = "segment";
static final String SEGMENT_TYPE = "INTEGER NOT NULL";
public static final String WAYPOINT = "waypoint";
static final String WAYPOINT_TYPE = "INTEGER NOT NULL";
public static final String URI = "uri";
static final String URI_TYPE = "TEXT";
static final String _ID_TYPE = "INTEGER PRIMARY KEY AUTOINCREMENT";
}
/**
* Columns from the media table.
*
* @author rene
*/
public static class MetaDataColumns
{
/** The track _id to which this segment belongs */
public static final String TRACK = "track";
static final String TRACK_TYPE = "INTEGER NOT NULL";
public static final String SEGMENT = "segment";
static final String SEGMENT_TYPE = "INTEGER";
public static final String WAYPOINT = "waypoint";
static final String WAYPOINT_TYPE = "INTEGER";
public static final String KEY = "key";
static final String KEY_TYPE = "TEXT NOT NULL";
public static final String VALUE = "value";
static final String VALUE_TYPE = "TEXT NOT NULL";
static final String _ID_TYPE = "INTEGER PRIMARY KEY AUTOINCREMENT";
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/db/GPStracking.java | Java | gpl3 | 13,886 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.db;
import java.util.Date;
import nl.sogeti.android.gpstracker.db.GPStracking.Media;
import nl.sogeti.android.gpstracker.db.GPStracking.MediaColumns;
import nl.sogeti.android.gpstracker.db.GPStracking.MetaData;
import nl.sogeti.android.gpstracker.db.GPStracking.Segments;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.db.GPStracking.TracksColumns;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.db.GPStracking.WaypointsColumns;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.location.Location;
import android.net.Uri;
import android.util.Log;
/**
* Class to hold bare-metal database operations exposed as functionality blocks
* To be used by database adapters, like a content provider, that implement a
* required functionality set
*
* @version $Id$
* @author rene (c) Jan 22, 2009, Sogeti B.V.
*/
public class DatabaseHelper extends SQLiteOpenHelper
{
private Context mContext;
private final static String TAG = "OGT.DatabaseHelper";
public DatabaseHelper(Context context)
{
super(context, GPStracking.DATABASE_NAME, null, GPStracking.DATABASE_VERSION);
this.mContext = context;
}
/*
* (non-Javadoc)
* @see
* android.database.sqlite.SQLiteOpenHelper#onCreate(android.database.sqlite
* .SQLiteDatabase)
*/
@Override
public void onCreate(SQLiteDatabase db)
{
db.execSQL(Waypoints.CREATE_STATEMENT);
db.execSQL(Segments.CREATE_STATMENT);
db.execSQL(Tracks.CREATE_STATEMENT);
db.execSQL(Media.CREATE_STATEMENT);
db.execSQL(MetaData.CREATE_STATEMENT);
}
/**
* Will update version 1 through 5 to version 8
*
* @see android.database.sqlite.SQLiteOpenHelper#onUpgrade(android.database.sqlite.SQLiteDatabase,
* int, int)
* @see GPStracking.DATABASE_VERSION
*/
@Override
public void onUpgrade(SQLiteDatabase db, int current, int targetVersion)
{
Log.i(TAG, "Upgrading db from " + current + " to " + targetVersion);
if (current <= 5) // From 1-5 to 6 (these before are the same before)
{
current = 6;
}
if (current == 6) // From 6 to 7 ( no changes )
{
current = 7;
}
if (current == 7) // From 7 to 8 ( more waypoints data )
{
for (String statement : Waypoints.UPGRADE_STATEMENT_7_TO_8)
{
db.execSQL(statement);
}
current = 8;
}
if (current == 8) // From 8 to 9 ( media Uri data )
{
db.execSQL(Media.CREATE_STATEMENT);
current = 9;
}
if (current == 9) // From 9 to 10 ( metadata )
{
db.execSQL(MetaData.CREATE_STATEMENT);
current = 10;
}
}
public void vacuum()
{
new Thread()
{
@Override
public void run()
{
SQLiteDatabase sqldb = getWritableDatabase();
sqldb.execSQL("VACUUM");
}
}.start();
}
int bulkInsertWaypoint(long trackId, long segmentId, ContentValues[] valuesArray)
{
if (trackId < 0 || segmentId < 0)
{
throw new IllegalArgumentException("Track and segments may not the less then 0.");
}
int inserted = 0;
SQLiteDatabase sqldb = getWritableDatabase();
sqldb.beginTransaction();
try
{
for (ContentValues args : valuesArray)
{
args.put(Waypoints.SEGMENT, segmentId);
long id = sqldb.insert(Waypoints.TABLE, null, args);
if (id >= 0)
{
inserted++;
}
}
sqldb.setTransactionSuccessful();
}
finally
{
if (sqldb.inTransaction())
{
sqldb.endTransaction();
}
}
return inserted;
}
/**
* Creates a waypoint under the current track segment with the current time
* on which the waypoint is reached
*
* @param track track
* @param segment segment
* @param latitude latitude
* @param longitude longitude
* @param time time
* @param speed the measured speed
* @return
*/
long insertWaypoint(long trackId, long segmentId, Location location)
{
if (trackId < 0 || segmentId < 0)
{
throw new IllegalArgumentException("Track and segments may not the less then 0.");
}
SQLiteDatabase sqldb = getWritableDatabase();
ContentValues args = new ContentValues();
args.put(WaypointsColumns.SEGMENT, segmentId);
args.put(WaypointsColumns.TIME, location.getTime());
args.put(WaypointsColumns.LATITUDE, location.getLatitude());
args.put(WaypointsColumns.LONGITUDE, location.getLongitude());
args.put(WaypointsColumns.SPEED, location.getSpeed());
args.put(WaypointsColumns.ACCURACY, location.getAccuracy());
args.put(WaypointsColumns.ALTITUDE, location.getAltitude());
args.put(WaypointsColumns.BEARING, location.getBearing());
long waypointId = sqldb.insert(Waypoints.TABLE, null, args);
ContentResolver resolver = this.mContext.getContentResolver();
Uri notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/waypoints");
resolver.notifyChange(notifyUri, null);
// Log.d( TAG, "Waypoint stored: "+notifyUri);
return waypointId;
}
/**
* Insert a URI for a given waypoint/segment/track in the media table
*
* @param trackId
* @param segmentId
* @param waypointId
* @param mediaUri
* @return
*/
long insertMedia(long trackId, long segmentId, long waypointId, String mediaUri)
{
if (trackId < 0 || segmentId < 0 || waypointId < 0)
{
throw new IllegalArgumentException("Track, segments and waypoint may not the less then 0.");
}
SQLiteDatabase sqldb = getWritableDatabase();
ContentValues args = new ContentValues();
args.put(MediaColumns.TRACK, trackId);
args.put(MediaColumns.SEGMENT, segmentId);
args.put(MediaColumns.WAYPOINT, waypointId);
args.put(MediaColumns.URI, mediaUri);
// Log.d( TAG, "Media stored in the datebase: "+mediaUri );
long mediaId = sqldb.insert(Media.TABLE, null, args);
ContentResolver resolver = this.mContext.getContentResolver();
Uri notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/waypoints/" + waypointId + "/media");
resolver.notifyChange(notifyUri, null);
// Log.d( TAG, "Notify: "+notifyUri );
resolver.notifyChange(Media.CONTENT_URI, null);
// Log.d( TAG, "Notify: "+Media.CONTENT_URI );
return mediaId;
}
/**
* Insert a key/value pair as meta-data for a track and optionally narrow the
* scope by segment or segment/waypoint
*
* @param trackId
* @param segmentId
* @param waypointId
* @param key
* @param value
* @return
*/
long insertOrUpdateMetaData(long trackId, long segmentId, long waypointId, String key, String value)
{
long metaDataId = -1;
if (trackId < 0 && key != null && value != null)
{
throw new IllegalArgumentException("Track, key and value must be provided");
}
if (waypointId >= 0 && segmentId < 0)
{
throw new IllegalArgumentException("Waypoint must have segment");
}
ContentValues args = new ContentValues();
args.put(MetaData.TRACK, trackId);
args.put(MetaData.SEGMENT, segmentId);
args.put(MetaData.WAYPOINT, waypointId);
args.put(MetaData.KEY, key);
args.put(MetaData.VALUE, value);
String whereClause = MetaData.TRACK + " = ? AND " + MetaData.SEGMENT + " = ? AND " + MetaData.WAYPOINT + " = ? AND " + MetaData.KEY + " = ?";
String[] whereArgs = new String[] { Long.toString(trackId), Long.toString(segmentId), Long.toString(waypointId), key };
SQLiteDatabase sqldb = getWritableDatabase();
int updated = sqldb.update(MetaData.TABLE, args, whereClause, whereArgs);
if (updated == 0)
{
metaDataId = sqldb.insert(MetaData.TABLE, null, args);
}
else
{
Cursor c = null;
try
{
c = sqldb.query(MetaData.TABLE, new String[] { MetaData._ID }, whereClause, whereArgs, null, null, null);
if( c.moveToFirst() )
{
metaDataId = c.getLong(0);
}
}
finally
{
if (c != null)
{
c.close();
}
}
}
ContentResolver resolver = this.mContext.getContentResolver();
Uri notifyUri;
if (segmentId >= 0 && waypointId >= 0)
{
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/waypoints/" + waypointId + "/metadata");
}
else if (segmentId >= 0)
{
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/metadata");
}
else
{
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/metadata");
}
resolver.notifyChange(notifyUri, null);
resolver.notifyChange(MetaData.CONTENT_URI, null);
return metaDataId;
}
/**
* Deletes a single track and all underlying segments, waypoints, media and
* metadata
*
* @param trackId
* @return
*/
int deleteTrack(long trackId)
{
SQLiteDatabase sqldb = getWritableDatabase();
int affected = 0;
Cursor cursor = null;
long segmentId = -1;
long metadataId = -1;
try
{
sqldb.beginTransaction();
// Iterate on each segement to delete each
cursor = sqldb.query(Segments.TABLE, new String[] { Segments._ID }, Segments.TRACK + "= ?", new String[] { String.valueOf(trackId) }, null, null,
null, null);
if (cursor.moveToFirst())
{
do
{
segmentId = cursor.getLong(0);
affected += deleteSegment(sqldb, trackId, segmentId);
}
while (cursor.moveToNext());
}
else
{
Log.e(TAG, "Did not find the last active segment");
}
// Delete the track
affected += sqldb.delete(Tracks.TABLE, Tracks._ID + "= ?", new String[] { String.valueOf(trackId) });
// Delete remaining meta-data
affected += sqldb.delete(MetaData.TABLE, MetaData.TRACK + "= ?", new String[] { String.valueOf(trackId) });
cursor = sqldb.query(MetaData.TABLE, new String[] { MetaData._ID }, MetaData.TRACK + "= ?", new String[] { String.valueOf(trackId) }, null, null,
null, null);
if (cursor.moveToFirst())
{
do
{
metadataId = cursor.getLong(0);
affected += deleteMetaData(metadataId);
}
while (cursor.moveToNext());
}
sqldb.setTransactionSuccessful();
}
finally
{
if (cursor != null)
{
cursor.close();
}
if (sqldb.inTransaction())
{
sqldb.endTransaction();
}
}
ContentResolver resolver = this.mContext.getContentResolver();
resolver.notifyChange(Tracks.CONTENT_URI, null);
resolver.notifyChange(ContentUris.withAppendedId(Tracks.CONTENT_URI, trackId), null);
return affected;
}
/**
* @param mediaId
* @return
*/
int deleteMedia(long mediaId)
{
SQLiteDatabase sqldb = getWritableDatabase();
Cursor cursor = null;
long trackId = -1;
long segmentId = -1;
long waypointId = -1;
try
{
cursor = sqldb.query(Media.TABLE, new String[] { Media.TRACK, Media.SEGMENT, Media.WAYPOINT }, Media._ID + "= ?",
new String[] { String.valueOf(mediaId) }, null, null, null, null);
if (cursor.moveToFirst())
{
trackId = cursor.getLong(0);
segmentId = cursor.getLong(0);
waypointId = cursor.getLong(0);
}
else
{
Log.e(TAG, "Did not find the media element to delete");
}
}
finally
{
if (cursor != null)
{
cursor.close();
}
}
int affected = sqldb.delete(Media.TABLE, Media._ID + "= ?", new String[] { String.valueOf(mediaId) });
ContentResolver resolver = this.mContext.getContentResolver();
Uri notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/waypoints/" + waypointId + "/media");
resolver.notifyChange(notifyUri, null);
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/media");
resolver.notifyChange(notifyUri, null);
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/media");
resolver.notifyChange(notifyUri, null);
resolver.notifyChange(ContentUris.withAppendedId(Media.CONTENT_URI, mediaId), null);
return affected;
}
int deleteMetaData(long metadataId)
{
SQLiteDatabase sqldb = getWritableDatabase();
Cursor cursor = null;
long trackId = -1;
long segmentId = -1;
long waypointId = -1;
try
{
cursor = sqldb.query(MetaData.TABLE, new String[] { MetaData.TRACK, MetaData.SEGMENT, MetaData.WAYPOINT }, MetaData._ID + "= ?",
new String[] { String.valueOf(metadataId) }, null, null, null, null);
if (cursor.moveToFirst())
{
trackId = cursor.getLong(0);
segmentId = cursor.getLong(0);
waypointId = cursor.getLong(0);
}
else
{
Log.e(TAG, "Did not find the media element to delete");
}
}
finally
{
if (cursor != null)
{
cursor.close();
}
}
int affected = sqldb.delete(MetaData.TABLE, MetaData._ID + "= ?", new String[] { String.valueOf(metadataId) });
ContentResolver resolver = this.mContext.getContentResolver();
Uri notifyUri;
if (trackId >= 0 && segmentId >= 0 && waypointId >= 0)
{
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/waypoints/" + waypointId + "/media");
resolver.notifyChange(notifyUri, null);
}
if (trackId >= 0 && segmentId >= 0)
{
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/media");
resolver.notifyChange(notifyUri, null);
}
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/media");
resolver.notifyChange(notifyUri, null);
resolver.notifyChange(ContentUris.withAppendedId(Media.CONTENT_URI, metadataId), null);
return affected;
}
/**
* Delete a segment and all member waypoints
*
* @param sqldb The SQLiteDatabase in question
* @param trackId The track id of this delete
* @param segmentId The segment that needs deleting
* @return
*/
int deleteSegment(SQLiteDatabase sqldb, long trackId, long segmentId)
{
int affected = sqldb.delete(Segments.TABLE, Segments._ID + "= ?", new String[] { String.valueOf(segmentId) });
// Delete all waypoints from segments
affected += sqldb.delete(Waypoints.TABLE, Waypoints.SEGMENT + "= ?", new String[] { String.valueOf(segmentId) });
// Delete all media from segment
affected += sqldb.delete(Media.TABLE, Media.TRACK + "= ? AND " + Media.SEGMENT + "= ?",
new String[] { String.valueOf(trackId), String.valueOf(segmentId) });
// Delete meta-data
affected += sqldb.delete(MetaData.TABLE, MetaData.TRACK + "= ? AND " + MetaData.SEGMENT + "= ?",
new String[] { String.valueOf(trackId), String.valueOf(segmentId) });
ContentResolver resolver = this.mContext.getContentResolver();
resolver.notifyChange(Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId), null);
resolver.notifyChange(Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments"), null);
return affected;
}
int updateTrack(long trackId, String name)
{
int updates;
String whereclause = Tracks._ID + " = " + trackId;
ContentValues args = new ContentValues();
args.put(Tracks.NAME, name);
// Execute the query.
SQLiteDatabase mDb = getWritableDatabase();
updates = mDb.update(Tracks.TABLE, args, whereclause, null);
ContentResolver resolver = this.mContext.getContentResolver();
Uri notifyUri = ContentUris.withAppendedId(Tracks.CONTENT_URI, trackId);
resolver.notifyChange(notifyUri, null);
return updates;
}
/**
* Insert a key/value pair as meta-data for a track and optionally narrow the
* scope by segment or segment/waypoint
*
* @param trackId
* @param segmentId
* @param waypointId
* @param key
* @param value
* @return
*/
int updateMetaData(long trackId, long segmentId, long waypointId, long metadataId, String selection, String[] selectionArgs, String value)
{
{
if ((metadataId < 0 && trackId < 0))
{
throw new IllegalArgumentException("Track or meta-data id be provided");
}
if (trackId >= 0 && (selection == null || !selection.contains("?") || selectionArgs.length != 1))
{
throw new IllegalArgumentException("A where clause selection must be provided to select the correct KEY");
}
if (trackId >= 0 && waypointId >= 0 && segmentId < 0)
{
throw new IllegalArgumentException("Waypoint must have segment");
}
SQLiteDatabase sqldb = getWritableDatabase();
String[] whereParams;
String whereclause;
if (metadataId >= 0)
{
whereclause = MetaData._ID + " = ? ";
whereParams = new String[] { Long.toString(metadataId) };
}
else
{
whereclause = MetaData.TRACK + " = ? AND " + MetaData.SEGMENT + " = ? AND " + MetaData.WAYPOINT + " = ? AND " + MetaData.KEY + " = ? ";
whereParams = new String[] { Long.toString(trackId), Long.toString(segmentId), Long.toString(waypointId), selectionArgs[0] };
}
ContentValues args = new ContentValues();
args.put(MetaData.VALUE, value);
int updates = sqldb.update(MetaData.TABLE, args, whereclause, whereParams);
ContentResolver resolver = this.mContext.getContentResolver();
Uri notifyUri;
if (trackId >= 0 && segmentId >= 0 && waypointId >= 0)
{
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/waypoints/" + waypointId + "/metadata");
}
else if (trackId >= 0 && segmentId >= 0)
{
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments/" + segmentId + "/metadata");
}
else if (trackId >= 0)
{
notifyUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/metadata");
}
else
{
notifyUri = Uri.withAppendedPath(MetaData.CONTENT_URI, "" + metadataId);
}
resolver.notifyChange(notifyUri, null);
resolver.notifyChange(MetaData.CONTENT_URI, null);
return updates;
}
}
/**
* Move to a fresh track with a new first segment for this track
*
* @return
*/
long toNextTrack(String name)
{
long currentTime = new Date().getTime();
ContentValues args = new ContentValues();
args.put(TracksColumns.NAME, name);
args.put(TracksColumns.CREATION_TIME, currentTime);
SQLiteDatabase sqldb = getWritableDatabase();
long trackId = sqldb.insert(Tracks.TABLE, null, args);
ContentResolver resolver = this.mContext.getContentResolver();
resolver.notifyChange(Tracks.CONTENT_URI, null);
return trackId;
}
/**
* Moves to a fresh segment to which waypoints can be connected
*
* @return
*/
long toNextSegment(long trackId)
{
SQLiteDatabase sqldb = getWritableDatabase();
ContentValues args = new ContentValues();
args.put(Segments.TRACK, trackId);
long segmentId = sqldb.insert(Segments.TABLE, null, args);
ContentResolver resolver = this.mContext.getContentResolver();
resolver.notifyChange(Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments"), null);
return segmentId;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/db/DatabaseHelper.java | Java | gpl3 | 22,575 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.db;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import nl.sogeti.android.gpstracker.db.GPStracking.Media;
import nl.sogeti.android.gpstracker.db.GPStracking.MetaData;
import nl.sogeti.android.gpstracker.db.GPStracking.Segments;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import android.app.SearchManager;
import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteQueryBuilder;
import android.location.Location;
import android.net.Uri;
import android.provider.LiveFolders;
import android.util.Log;
/**
* Goal of this Content Provider is to make the GPS Tracking information uniformly
* available to this application and even other applications. The GPS-tracking
* database can hold, tracks, segments or waypoints
* <p>
* A track is an actual route taken from start to finish. All the GPS locations
* collected are waypoints. Waypoints taken in sequence without loss of GPS-signal
* are considered connected and are grouped in segments. A route is build up out of
* 1 or more segments.
* <p>
* For example:<br>
* <code>content://nl.sogeti.android.gpstracker/tracks</code>
* is the URI that returns all the stored tracks or starts a new track on insert
* <p>
* <code>content://nl.sogeti.android.gpstracker/tracks/2</code>
* is the URI string that would return a single result row, the track with ID = 23.
* <p>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/segments</code> is the URI that returns
* all the stored segments of a track with ID = 2 or starts a new segment on insert
* <p>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/waypoints</code> is the URI that returns
* all the stored waypoints of a track with ID = 2
* <p>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/segments</code> is the URI that returns
* all the stored segments of a track with ID = 2
* <p>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/segments/3</code> is
* the URI string that would return a single result row, the segment with ID = 3 of a track with ID = 2 .
* <p>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/segments/1/waypoints</code> is the URI that
* returns all the waypoints of a segment 1 of track 2.
* <p>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/segments/1/waypoints/52</code> is the URI string that
* would return a single result row, the waypoint with ID = 52
* <p>
* Media is stored under a waypoint and may be queried as:<br>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/segments/3/waypoints/22/media</code>
* <p>
*
*
* All media for a segment can be queried with:<br>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/segments/3/media</code>
* <p>
* All media for a track can be queried with:<br>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/media</code>
*
* <p>
* The whole set of collected media may be queried as:<br>
* <code>content://nl.sogeti.android.gpstracker/media</code>
* <p>
* A single media is stored with an ID, for instance ID = 12:<br>
* <code>content://nl.sogeti.android.gpstracker/media/12</code>
* <p>
* The whole set of collected media may be queried as:<br>
* <code>content://nl.sogeti.android.gpstracker/media</code>
* <p>
*
*
* Meta-data regarding a single waypoint may be queried as:<br>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/segments/3/waypoints/22/metadata</code>
* <p>
* Meta-data regarding a single segment as whole may be queried as:<br>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/segments/3/metadata</code>
* Note: This does not include meta-data of waypoints.
* <p>
* Meta-data regarding a single track as a whole may be queried as:<br>
* <code>content://nl.sogeti.android.gpstracker/tracks/2/metadata</code>
* Note: This does not include meta-data of waypoints or segments.
*
* @version $Id$
* @author rene (c) Jan 22, 2009, Sogeti B.V.
*/
public class GPStrackingProvider extends ContentProvider
{
private static final String TAG = "OGT.GPStrackingProvider";
/* Action types as numbers for using the UriMatcher */
private static final int TRACKS = 1;
private static final int TRACK_ID = 2;
private static final int TRACK_MEDIA = 3;
private static final int TRACK_WAYPOINTS = 4;
private static final int SEGMENTS = 5;
private static final int SEGMENT_ID = 6;
private static final int SEGMENT_MEDIA = 7;
private static final int WAYPOINTS = 8;
private static final int WAYPOINT_ID = 9;
private static final int WAYPOINT_MEDIA = 10;
private static final int SEARCH_SUGGEST_ID = 11;
private static final int LIVE_FOLDERS = 12;
private static final int MEDIA = 13;
private static final int MEDIA_ID = 14;
private static final int TRACK_METADATA = 15;
private static final int SEGMENT_METADATA = 16;
private static final int WAYPOINT_METADATA = 17;
private static final int METADATA = 18;
private static final int METADATA_ID = 19;
private static final String[] SUGGEST_PROJECTION =
new String[]
{
Tracks._ID,
Tracks.NAME+" AS "+SearchManager.SUGGEST_COLUMN_TEXT_1,
"datetime("+Tracks.CREATION_TIME+"/1000, 'unixepoch') as "+SearchManager.SUGGEST_COLUMN_TEXT_2,
Tracks._ID+" AS "+SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID
};
private static final String[] LIVE_PROJECTION =
new String[]
{
Tracks._ID+" AS "+LiveFolders._ID,
Tracks.NAME+" AS "+ LiveFolders.NAME,
"datetime("+Tracks.CREATION_TIME+"/1000, 'unixepoch') as "+LiveFolders.DESCRIPTION
};
private static UriMatcher sURIMatcher = new UriMatcher( UriMatcher.NO_MATCH );
/**
* Although it is documented that in addURI(null, path, 0) "path" should be an absolute path this does not seem to work. A relative path gets the jobs done and matches an absolute path.
*/
static
{
GPStrackingProvider.sURIMatcher = new UriMatcher( UriMatcher.NO_MATCH );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks", GPStrackingProvider.TRACKS );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#", GPStrackingProvider.TRACK_ID );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/media", GPStrackingProvider.TRACK_MEDIA );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/metadata", GPStrackingProvider.TRACK_METADATA );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/waypoints", GPStrackingProvider.TRACK_WAYPOINTS );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/segments", GPStrackingProvider.SEGMENTS );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/segments/#", GPStrackingProvider.SEGMENT_ID );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/segments/#/media", GPStrackingProvider.SEGMENT_MEDIA );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/segments/#/metadata", GPStrackingProvider.SEGMENT_METADATA );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/segments/#/waypoints", GPStrackingProvider.WAYPOINTS );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/segments/#/waypoints/#", GPStrackingProvider.WAYPOINT_ID );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/segments/#/waypoints/#/media", GPStrackingProvider.WAYPOINT_MEDIA );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "tracks/#/segments/#/waypoints/#/metadata", GPStrackingProvider.WAYPOINT_METADATA );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "media", GPStrackingProvider.MEDIA );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "media/#", GPStrackingProvider.MEDIA_ID );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "metadata", GPStrackingProvider.METADATA );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "metadata/#", GPStrackingProvider.METADATA_ID );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "live_folders/tracks", GPStrackingProvider.LIVE_FOLDERS );
GPStrackingProvider.sURIMatcher.addURI( GPStracking.AUTHORITY, "search_suggest_query", GPStrackingProvider.SEARCH_SUGGEST_ID );
}
private DatabaseHelper mDbHelper;
/**
* (non-Javadoc)
* @see android.content.ContentProvider#onCreate()
*/
@Override
public boolean onCreate()
{
if (this.mDbHelper == null)
{
this.mDbHelper = new DatabaseHelper( getContext() );
}
return true;
}
/**
* (non-Javadoc)
* @see android.content.ContentProvider#getType(android.net.Uri)
*/
@Override
public String getType( Uri uri )
{
int match = GPStrackingProvider.sURIMatcher.match( uri );
String mime = null;
switch (match)
{
case TRACKS:
mime = Tracks.CONTENT_TYPE;
break;
case TRACK_ID:
mime = Tracks.CONTENT_ITEM_TYPE;
break;
case SEGMENTS:
mime = Segments.CONTENT_TYPE;
break;
case SEGMENT_ID:
mime = Segments.CONTENT_ITEM_TYPE;
break;
case WAYPOINTS:
mime = Waypoints.CONTENT_TYPE;
break;
case WAYPOINT_ID:
mime = Waypoints.CONTENT_ITEM_TYPE;
break;
case MEDIA_ID:
case TRACK_MEDIA:
case SEGMENT_MEDIA:
case WAYPOINT_MEDIA:
mime = Media.CONTENT_ITEM_TYPE;
break;
case METADATA_ID:
case TRACK_METADATA:
case SEGMENT_METADATA:
case WAYPOINT_METADATA:
mime = MetaData.CONTENT_ITEM_TYPE;
break;
case UriMatcher.NO_MATCH:
default:
Log.w(TAG, "There is not MIME type defined for URI "+uri);
break;
}
return mime;
}
/**
* (non-Javadoc)
* @see android.content.ContentProvider#insert(android.net.Uri, android.content.ContentValues)
*/
@Override
public Uri insert( Uri uri, ContentValues values )
{
//Log.d( TAG, "insert on "+uri );
Uri insertedUri = null;
int match = GPStrackingProvider.sURIMatcher.match( uri );
List<String> pathSegments = null;
long trackId = -1;
long segmentId = -1;
long waypointId = -1;
long mediaId = -1;
String key;
String value;
switch (match)
{
case WAYPOINTS:
pathSegments = uri.getPathSegments();
trackId = Long.parseLong( pathSegments.get( 1 ) );
segmentId = Long.parseLong( pathSegments.get( 3 ) );
Location loc = new Location( TAG );
Double latitude = values.getAsDouble( Waypoints.LATITUDE );
Double longitude = values.getAsDouble( Waypoints.LONGITUDE );
Long time = values.getAsLong( Waypoints.TIME );
Float speed = values.getAsFloat( Waypoints.SPEED );
if( time == null )
{
time = System.currentTimeMillis();
}
if( speed == null )
{
speed = 0f;
}
loc.setLatitude( latitude );
loc.setLongitude( longitude );
loc.setTime( time );
loc.setSpeed( speed );
if( values.containsKey( Waypoints.ACCURACY ) )
{
loc.setAccuracy( values.getAsFloat( Waypoints.ACCURACY ) );
}
if( values.containsKey( Waypoints.ALTITUDE ) )
{
loc.setAltitude( values.getAsDouble( Waypoints.ALTITUDE ) );
}
if( values.containsKey( Waypoints.BEARING ) )
{
loc.setBearing( values.getAsFloat( Waypoints.BEARING ) );
}
waypointId = this.mDbHelper.insertWaypoint(
trackId,
segmentId,
loc );
// Log.d( TAG, "Have inserted to segment "+segmentId+" with waypoint "+waypointId );
insertedUri = ContentUris.withAppendedId( uri, waypointId );
break;
case WAYPOINT_MEDIA:
pathSegments = uri.getPathSegments();
trackId = Long.parseLong( pathSegments.get( 1 ) );
segmentId = Long.parseLong( pathSegments.get( 3 ) );
waypointId = Long.parseLong( pathSegments.get( 5 ) );
String mediaUri = values.getAsString( Media.URI );
mediaId = this.mDbHelper.insertMedia( trackId, segmentId, waypointId, mediaUri );
insertedUri = ContentUris.withAppendedId( Media.CONTENT_URI, mediaId );
break;
case SEGMENTS:
pathSegments = uri.getPathSegments();
trackId = Integer.parseInt( pathSegments.get( 1 ) );
segmentId = this.mDbHelper.toNextSegment( trackId );
insertedUri = ContentUris.withAppendedId( uri, segmentId );
break;
case TRACKS:
String name = ( values == null ) ? "" : values.getAsString( Tracks.NAME );
trackId = this.mDbHelper.toNextTrack( name );
insertedUri = ContentUris.withAppendedId( uri, trackId );
break;
case TRACK_METADATA:
pathSegments = uri.getPathSegments();
trackId = Long.parseLong( pathSegments.get( 1 ) );
key = values.getAsString( MetaData.KEY );
value = values.getAsString( MetaData.VALUE );
mediaId = this.mDbHelper.insertOrUpdateMetaData( trackId, -1L, -1L, key, value );
insertedUri = ContentUris.withAppendedId( MetaData.CONTENT_URI, mediaId );
break;
case SEGMENT_METADATA:
pathSegments = uri.getPathSegments();
trackId = Long.parseLong( pathSegments.get( 1 ) );
segmentId = Long.parseLong( pathSegments.get( 3 ) );
key = values.getAsString( MetaData.KEY );
value = values.getAsString( MetaData.VALUE );
mediaId = this.mDbHelper.insertOrUpdateMetaData( trackId, segmentId, -1L, key, value );
insertedUri = ContentUris.withAppendedId( MetaData.CONTENT_URI, mediaId );
break;
case WAYPOINT_METADATA:
pathSegments = uri.getPathSegments();
trackId = Long.parseLong( pathSegments.get( 1 ) );
segmentId = Long.parseLong( pathSegments.get( 3 ) );
waypointId = Long.parseLong( pathSegments.get( 5 ) );
key = values.getAsString( MetaData.KEY );
value = values.getAsString( MetaData.VALUE );
mediaId = this.mDbHelper.insertOrUpdateMetaData( trackId, segmentId, waypointId, key, value );
insertedUri = ContentUris.withAppendedId( MetaData.CONTENT_URI, mediaId );
break;
default:
Log.e( GPStrackingProvider.TAG, "Unable to match the insert URI: " + uri.toString() );
insertedUri = null;
break;
}
return insertedUri;
}
/**
* (non-Javadoc)
* @see android.content.ContentProvider#query(android.net.Uri, java.lang.String[], java.lang.String, java.lang.String[], java.lang.String)
*/
@Override
public Cursor query( Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder )
{
// Log.d( TAG, "Query on Uri:"+uri );
int match = GPStrackingProvider.sURIMatcher.match( uri );
String tableName = null;
String innerSelection = "1";
String[] innerSelectionArgs = new String[]{};
String sortorder = sortOrder;
List<String> pathSegments = uri.getPathSegments();
switch (match)
{
case TRACKS:
tableName = Tracks.TABLE;
break;
case TRACK_ID:
tableName = Tracks.TABLE;
innerSelection = Tracks._ID + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ) };
break;
case SEGMENTS:
tableName = Segments.TABLE;
innerSelection = Segments.TRACK + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ) };
break;
case SEGMENT_ID:
tableName = Segments.TABLE;
innerSelection = Segments.TRACK + " = ? and " + Segments._ID + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ), pathSegments.get( 3 ) };
break;
case WAYPOINTS:
tableName = Waypoints.TABLE;
innerSelection = Waypoints.SEGMENT + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 3 ) };
break;
case WAYPOINT_ID:
tableName = Waypoints.TABLE;
innerSelection = Waypoints.SEGMENT + " = ? and " + Waypoints._ID + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 3 ), pathSegments.get( 5 ) };
break;
case TRACK_WAYPOINTS:
tableName = Waypoints.TABLE + " INNER JOIN " + Segments.TABLE + " ON "+ Segments.TABLE+"."+Segments._ID +"=="+ Waypoints.SEGMENT;
innerSelection = Segments.TRACK + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ) };
break;
case GPStrackingProvider.MEDIA:
tableName = Media.TABLE;
break;
case GPStrackingProvider.MEDIA_ID:
tableName = Media.TABLE;
innerSelection = Media._ID + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ) };
break;
case TRACK_MEDIA:
tableName = Media.TABLE;
innerSelection = Media.TRACK + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ) };
break;
case SEGMENT_MEDIA:
tableName = Media.TABLE;
innerSelection = Media.TRACK + " = ? and " + Media.SEGMENT + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ), pathSegments.get( 3 ) };
break;
case WAYPOINT_MEDIA:
tableName = Media.TABLE;
innerSelection = Media.TRACK + " = ? and " + Media.SEGMENT + " = ? and " + Media.WAYPOINT + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ),pathSegments.get( 3 ), pathSegments.get( 5 )};
break;
case TRACK_METADATA:
tableName = MetaData.TABLE;
innerSelection = MetaData.TRACK + " = ? and " + MetaData.SEGMENT + " = ? and " + MetaData.WAYPOINT + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ), "-1", "-1" };
break;
case SEGMENT_METADATA:
tableName = MetaData.TABLE;
innerSelection = MetaData.TRACK + " = ? and " + MetaData.SEGMENT + " = ? and " + MetaData.WAYPOINT + " = ? ";
innerSelectionArgs = new String[]{pathSegments.get( 1 ), pathSegments.get( 3 ), "-1" };
break;
case WAYPOINT_METADATA:
tableName = MetaData.TABLE;
innerSelection = MetaData.TRACK + " = ? and " + MetaData.SEGMENT + " = ? and " + MetaData.WAYPOINT + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ), pathSegments.get( 3 ), pathSegments.get( 5 ) };
break;
case GPStrackingProvider.METADATA:
tableName = MetaData.TABLE;
break;
case GPStrackingProvider.METADATA_ID:
tableName = MetaData.TABLE;
innerSelection = MetaData._ID + " = ? ";
innerSelectionArgs = new String[]{ pathSegments.get( 1 ) };
break;
case SEARCH_SUGGEST_ID:
tableName = Tracks.TABLE;
if( selectionArgs[0] == null || selectionArgs[0].equals( "" ) )
{
selection = null;
selectionArgs = null;
sortorder = Tracks.CREATION_TIME+" desc";
}
else
{
selectionArgs[0] = "%" +selectionArgs[0]+ "%";
}
projection = SUGGEST_PROJECTION;
break;
case LIVE_FOLDERS:
tableName = Tracks.TABLE;
projection = LIVE_PROJECTION;
sortorder = Tracks.CREATION_TIME+" desc";
break;
default:
Log.e( GPStrackingProvider.TAG, "Unable to come to an action in the query uri: " + uri.toString() );
return null;
}
// SQLiteQueryBuilder is a helper class that creates the
// proper SQL syntax for us.
SQLiteQueryBuilder qBuilder = new SQLiteQueryBuilder();
// Set the table we're querying.
qBuilder.setTables( tableName );
if( selection == null )
{
selection = innerSelection;
}
else
{
selection = "( "+ innerSelection + " ) and " + selection;
}
LinkedList<String> allArgs = new LinkedList<String>();
if( selectionArgs == null )
{
allArgs.addAll(Arrays.asList(innerSelectionArgs));
}
else
{
allArgs.addAll(Arrays.asList(innerSelectionArgs));
allArgs.addAll(Arrays.asList(selectionArgs));
}
selectionArgs = allArgs.toArray(innerSelectionArgs);
// Make the query.
SQLiteDatabase mDb = this.mDbHelper.getWritableDatabase();
Cursor c = qBuilder.query( mDb, projection, selection, selectionArgs, null, null, sortorder );
c.setNotificationUri( getContext().getContentResolver(), uri );
return c;
}
/**
* (non-Javadoc)
* @see android.content.ContentProvider#update(android.net.Uri, android.content.ContentValues, java.lang.String, java.lang.String[])
*/
@Override
public int update( Uri uri, ContentValues givenValues, String selection, String[] selectionArgs )
{
int updates = -1 ;
long trackId;
long segmentId;
long waypointId;
long metaDataId;
List<String> pathSegments;
int match = GPStrackingProvider.sURIMatcher.match( uri );
String value;
switch (match)
{
case TRACK_ID:
trackId = new Long( uri.getLastPathSegment() ).longValue();
String name = givenValues.getAsString( Tracks.NAME );
updates = mDbHelper.updateTrack(trackId, name);
break;
case TRACK_METADATA:
pathSegments = uri.getPathSegments();
trackId = Long.parseLong( pathSegments.get( 1 ) );
value = givenValues.getAsString( MetaData.VALUE );
updates = mDbHelper.updateMetaData( trackId, -1L, -1L, -1L, selection, selectionArgs, value);
break;
case SEGMENT_METADATA:
pathSegments = uri.getPathSegments();
trackId = Long.parseLong( pathSegments.get( 1 ) );
segmentId = Long.parseLong( pathSegments.get( 3 ) );
value = givenValues.getAsString( MetaData.VALUE );
updates = mDbHelper.updateMetaData( trackId, segmentId, -1L, -1L, selection, selectionArgs, value);
break;
case WAYPOINT_METADATA:
pathSegments = uri.getPathSegments();
trackId = Long.parseLong( pathSegments.get( 1 ) );
segmentId = Long.parseLong( pathSegments.get( 3 ) );
waypointId = Long.parseLong( pathSegments.get( 5 ) );
value = givenValues.getAsString( MetaData.VALUE );
updates = mDbHelper.updateMetaData( trackId, segmentId, waypointId, -1L, selection, selectionArgs, value);
break;
case METADATA_ID:
pathSegments = uri.getPathSegments();
metaDataId = Long.parseLong( pathSegments.get( 1 ) );
value = givenValues.getAsString( MetaData.VALUE );
updates = mDbHelper.updateMetaData( -1L, -1L, -1L, metaDataId, selection, selectionArgs, value);
break;
default:
Log.e( GPStrackingProvider.TAG, "Unable to come to an action in the query uri" + uri.toString() );
return -1;
}
return updates;
}
/**
* (non-Javadoc)
* @see android.content.ContentProvider#delete(android.net.Uri, java.lang.String, java.lang.String[])
*/
@Override
public int delete( Uri uri, String selection, String[] selectionArgs )
{
int match = GPStrackingProvider.sURIMatcher.match( uri );
int affected = 0;
switch( match )
{
case GPStrackingProvider.TRACK_ID:
affected = this.mDbHelper.deleteTrack( new Long( uri.getLastPathSegment() ).longValue() );
break;
case GPStrackingProvider.MEDIA_ID:
affected = this.mDbHelper.deleteMedia( new Long( uri.getLastPathSegment() ).longValue() );
break;
case GPStrackingProvider.METADATA_ID:
affected = this.mDbHelper.deleteMetaData( new Long( uri.getLastPathSegment() ).longValue() );
break;
default:
affected = 0;
break;
}
return affected;
}
@Override
public int bulkInsert( Uri uri, ContentValues[] valuesArray )
{
int inserted = 0;
int match = GPStrackingProvider.sURIMatcher.match( uri );
switch (match)
{
case WAYPOINTS:
List<String> pathSegments = uri.getPathSegments();
int trackId = Integer.parseInt( pathSegments.get( 1 ) );
int segmentId = Integer.parseInt( pathSegments.get( 3 ) );
inserted = this.mDbHelper.bulkInsertWaypoint( trackId, segmentId, valuesArray );
break;
default:
inserted = super.bulkInsert( uri, valuesArray );
break;
}
return inserted;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/db/GPStrackingProvider.java | Java | gpl3 | 28,917 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.adapter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OptionalDataException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Observable;
import java.util.Set;
import java.util.Vector;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.db.GPStracking.MetaData;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.Pair;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.util.Log;
import android.widget.ArrayAdapter;
import android.widget.SpinnerAdapter;
/**
* Model containing agregrated data retrieved from the GoBreadcrumbs.com API
*
* @version $Id:$
* @author rene (c) May 9, 2011, Sogeti B.V.
*/
public class BreadcrumbsTracks extends Observable
{
public static final String DESCRIPTION = "DESCRIPTION";
public static final String NAME = "NAME";
public static final String ENDTIME = "ENDTIME";
public static final String TRACK_ID = "BREADCRUMBS_TRACK_ID";
public static final String BUNDLE_ID = "BREADCRUMBS_BUNDLE_ID";
public static final String ACTIVITY_ID = "BREADCRUMBS_ACTIVITY_ID";
public static final String DIFFICULTY = "DIFFICULTY";
public static final String STARTTIME = "STARTTIME";
public static final String ISPUBLIC = "ISPUBLIC";
public static final String RATING = "RATING";
public static final String LATITUDE = "LATITUDE";
public static final String LONGITUDE = "LONGITUDE";
public static final String TOTALDISTANCE = "TOTALDISTANCE";
public static final String TOTALTIME = "TOTALTIME";
private static final String TAG = "OGT.BreadcrumbsTracks";
private static final Integer CACHE_VERSION = Integer.valueOf(8);
private static final String BREADCRUMSB_BUNDLES_CACHE_FILE = "breadcrumbs_bundles_cache.data";
private static final String BREADCRUMSB_ACTIVITY_CACHE_FILE = "breadcrumbs_activity_cache.data";
/**
* Time in milliseconds that a persisted breadcrumbs cache is used without a
* refresh
*/
private static final long CACHE_TIMEOUT = 1000 * 60;//1000*60*10 ;
/**
* Mapping from bundleId to a list of trackIds
*/
private static HashMap<Integer, List<Integer>> sBundlesWithTracks;
/**
* Map from activityId to a dictionary containing keys like NAME
*/
private static HashMap<Integer, Map<String, String>> sActivityMappings;
/**
* Map from bundleId to a dictionary containing keys like NAME and
* DESCRIPTION
*/
private static HashMap<Integer, Map<String, String>> sBundleMappings;
/**
* Map from trackId to a dictionary containing keys like NAME, ISPUBLIC,
* DESCRIPTION and more
*/
private static HashMap<Integer, Map<String, String>> sTrackMappings;
/**
* Cache of OGT Tracks that have a Breadcrumbs track id stored in the
* meta-data table
*/
private Map<Long, Integer> mSyncedTracks = null;
private static Set<Pair<Integer, Integer>> sScheduledTracksLoading;
static
{
BreadcrumbsTracks.initCacheVariables();
}
private static void initCacheVariables()
{
sBundlesWithTracks = new HashMap<Integer, List<Integer>>();
sActivityMappings = new HashMap<Integer, Map<String, String>>();
sBundleMappings = new HashMap<Integer, Map<String, String>>();
sTrackMappings = new HashMap<Integer, Map<String, String>>();
sScheduledTracksLoading = new HashSet<Pair<Integer, Integer>>();
}
private ContentResolver mResolver;
/**
* Constructor: create a new BreadcrumbsTracks.
*
* @param resolver Content resolver to obtain local Breadcrumbs references
*/
public BreadcrumbsTracks(ContentResolver resolver)
{
mResolver = resolver;
}
public void addActivity(int activityId, String activityName)
{
if (BreadcrumbsAdapter.DEBUG)
{
Log.d(TAG, "addActivity(Integer " + activityId + " String " + activityName + ")");
}
if (sActivityMappings.get(activityId) == null)
{
sActivityMappings.put(activityId, new HashMap<String, String>());
}
sActivityMappings.get(activityId).put(NAME, activityName);
setChanged();
notifyObservers();
}
/**
* Add bundle to the track list
*
* @param activityId
* @param bundleId
* @param bundleName
* @param bundleDescription
*/
public void addBundle(int bundleId, String bundleName, String bundleDescription)
{
if (BreadcrumbsAdapter.DEBUG)
{
Log.d(TAG, "addBundle(Integer " + bundleId + ", String " + bundleName + ", String " + bundleDescription + ")");
}
if (sBundleMappings.get(bundleId) == null)
{
sBundleMappings.put(bundleId, new HashMap<String, String>());
}
if (sBundlesWithTracks.get(bundleId) == null)
{
sBundlesWithTracks.put(bundleId, new ArrayList<Integer>());
}
sBundleMappings.get(bundleId).put(NAME, bundleName);
sBundleMappings.get(bundleId).put(DESCRIPTION, bundleDescription);
setChanged();
notifyObservers();
}
/**
* Add track to tracklist
*
* @param trackId
* @param trackName
* @param bundleId
* @param trackDescription
* @param difficulty
* @param startTime
* @param endTime
* @param isPublic
* @param lat
* @param lng
* @param totalDistance
* @param totalTime
* @param trackRating
*/
public void addTrack(int trackId, String trackName, int bundleId, String trackDescription, String difficulty, String startTime, String endTime,
String isPublic, Float lat, Float lng, Float totalDistance, Integer totalTime, String trackRating)
{
if (BreadcrumbsAdapter.DEBUG)
{
Log.d(TAG, "addTrack(Integer " + trackId + ", String " + trackName + ", Integer " + bundleId + "...");
}
if (sBundlesWithTracks.get(bundleId) == null)
{
sBundlesWithTracks.put(bundleId, new ArrayList<Integer>());
}
if (!sBundlesWithTracks.get(bundleId).contains(trackId))
{
sBundlesWithTracks.get(bundleId).add(trackId);
sScheduledTracksLoading.remove(Pair.create(Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE, trackId));
}
if (sTrackMappings.get(trackId) == null)
{
sTrackMappings.put(trackId, new HashMap<String, String>());
}
putForTrack(trackId, NAME, trackName);
putForTrack(trackId, ISPUBLIC, isPublic);
putForTrack(trackId, STARTTIME, startTime);
putForTrack(trackId, ENDTIME, endTime);
putForTrack(trackId, DESCRIPTION, trackDescription);
putForTrack(trackId, DIFFICULTY, difficulty);
putForTrack(trackId, RATING, trackRating);
putForTrack(trackId, LATITUDE, lat);
putForTrack(trackId, LONGITUDE, lng);
putForTrack(trackId, TOTALDISTANCE, totalDistance);
putForTrack(trackId, TOTALTIME, totalTime);
notifyObservers();
}
public void addSyncedTrack(Long trackId, int bcTrackId)
{
if (mSyncedTracks == null)
{
isLocalTrackOnline(-1l);
}
mSyncedTracks.put(trackId, bcTrackId);
setChanged();
notifyObservers();
}
public void addTracksLoadingScheduled(Pair<Integer, Integer> item)
{
sScheduledTracksLoading.add(item);
setChanged();
notifyObservers();
}
/**
* Cleans old bundles based a set of all bundles
*
* @param newBundleIds
*/
public void setAllBundleIds(Set<Integer> currentBundleIds)
{
Set<Integer> keySet = sBundlesWithTracks.keySet();
for (Integer oldBundleId : keySet)
{
if (!currentBundleIds.contains(oldBundleId))
{
removeBundle(oldBundleId);
}
}
}
public void setAllTracksForBundleId(int mBundleId, Set<Integer> updatedbcTracksIdList)
{
List<Integer> trackIdList = sBundlesWithTracks.get(mBundleId);
for (int location = 0; location < trackIdList.size(); location++)
{
Integer oldTrackId = trackIdList.get(location);
if (!updatedbcTracksIdList.contains(oldTrackId))
{
removeTrack(mBundleId, oldTrackId);
}
}
setChanged();
notifyObservers();
}
private void putForTrack(int trackId, String key, Object value)
{
if (value != null)
{
sTrackMappings.get(trackId).put(key, value.toString());
}
setChanged();
notifyObservers();
}
/**
* Remove a bundle
*
* @param deletedId
*/
public void removeBundle(int deletedId)
{
sBundleMappings.remove(deletedId);
sBundlesWithTracks.remove(deletedId);
setChanged();
notifyObservers();
}
/**
* Remove a track
*
* @param deletedId
*/
public void removeTrack(int bundleId, int trackId)
{
sTrackMappings.remove(trackId);
if (sBundlesWithTracks.get(bundleId) != null)
{
sBundlesWithTracks.get(bundleId).remove(trackId);
}
setChanged();
notifyObservers();
mResolver.delete(MetaData.CONTENT_URI, MetaData.TRACK + " = ? AND " + MetaData.KEY + " = ? ", new String[] { Integer.toString(trackId), TRACK_ID });
if (mSyncedTracks != null && mSyncedTracks.containsKey(trackId))
{
mSyncedTracks.remove(trackId);
}
}
public int positions()
{
int size = 0;
for (int index = 0; index < sBundlesWithTracks.size(); index++)
{
// One row for the Bundle header
size += 1;
List<Integer> trackIds = sBundlesWithTracks.get(index);
int bundleSize = trackIds != null ? trackIds.size() : 0;
// One row per track in each bundle
size += bundleSize;
}
return size;
}
public Integer getBundleIdForTrackId(int trackId)
{
for (Integer bundleId : sBundlesWithTracks.keySet())
{
List<Integer> trackIds = sBundlesWithTracks.get(bundleId);
if (trackIds.contains(trackId))
{
return bundleId;
}
}
return null;
}
/**
* @param position list postition 0...n
* @return a pair of a TYPE and an ID
*/
public Pair<Integer, Integer> getItemForPosition(int position)
{
int countdown = position;
for (Integer bundleId : sBundlesWithTracks.keySet())
{
if (countdown == 0)
{
return Pair.create(Constants.BREADCRUMBS_BUNDLE_ITEM_VIEW_TYPE, bundleId);
}
countdown--;
int bundleSize = sBundlesWithTracks.get(bundleId) != null ? sBundlesWithTracks.get(bundleId).size() : 0;
if (countdown < bundleSize)
{
Integer trackId = sBundlesWithTracks.get(bundleId).get(countdown);
return Pair.create(Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE, trackId);
}
countdown -= bundleSize;
}
return null;
}
public String getValueForItem(Pair<Integer, Integer> item, String key)
{
String value = null;
switch (item.first)
{
case Constants.BREADCRUMBS_BUNDLE_ITEM_VIEW_TYPE:
value = sBundleMappings.get(item.second).get(key);
break;
case Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE:
value = sTrackMappings.get(item.second).get(key);
break;
default:
value = null;
break;
}
return value;
}
public SpinnerAdapter getActivityAdapter(Context ctx)
{
List<String> activities = new Vector<String>();
for (Integer activityId : sActivityMappings.keySet())
{
String name = sActivityMappings.get(activityId).get(NAME);
name = name != null ? name : "";
activities.add(name);
}
Collections.sort(activities);
ArrayAdapter<String> adapter = new ArrayAdapter<String>(ctx, android.R.layout.simple_spinner_item, activities);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
return adapter;
}
public SpinnerAdapter getBundleAdapter(Context ctx)
{
List<String> bundles = new Vector<String>();
for (Integer bundleId : sBundlesWithTracks.keySet())
{
bundles.add(sBundleMappings.get(bundleId).get(NAME));
}
Collections.sort(bundles);
if (!bundles.contains(ctx.getString(R.string.app_name)))
{
bundles.add(ctx.getString(R.string.app_name));
}
ArrayAdapter<String> adapter = new ArrayAdapter<String>(ctx, android.R.layout.simple_spinner_item, bundles);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
return adapter;
}
public static int getIdForActivity(String selectedItem)
{
if (selectedItem == null)
{
return -1;
}
for (Integer activityId : sActivityMappings.keySet())
{
Map<String, String> mapping = sActivityMappings.get(activityId);
if (mapping != null && selectedItem.equals(mapping.get(NAME)))
{
return activityId;
}
}
return -1;
}
public static int getIdForBundle(int activityId, String selectedItem)
{
for (Integer bundleId : sBundlesWithTracks.keySet())
{
if (selectedItem.equals(sBundleMappings.get(bundleId).get(NAME)))
{
return bundleId;
}
}
return -1;
}
private boolean isLocalTrackOnline(Long qtrackId)
{
if (mSyncedTracks == null)
{
mSyncedTracks = new HashMap<Long, Integer>();
Cursor cursor = null;
try
{
cursor = mResolver.query(MetaData.CONTENT_URI, new String[] { MetaData.TRACK, MetaData.VALUE }, MetaData.KEY + " = ? ", new String[] { TRACK_ID },
null);
if (cursor.moveToFirst())
{
do
{
Long trackId = cursor.getLong(0);
try
{
Integer bcTrackId = Integer.valueOf(cursor.getString(1));
mSyncedTracks.put(trackId, bcTrackId);
}
catch (NumberFormatException e)
{
Log.w(TAG, "Illigal value stored as track id", e);
}
}
while (cursor.moveToNext());
}
}
finally
{
if (cursor != null)
{
cursor.close();
}
}
setChanged();
notifyObservers();
}
boolean synced = mSyncedTracks.containsKey(qtrackId);
return synced;
}
public boolean isLocalTrackSynced(Long qtrackId)
{
boolean uploaded = isLocalTrackOnline(qtrackId);
Integer trackId = mSyncedTracks.get(qtrackId);
boolean synced = trackId != null && sTrackMappings.get(trackId) != null;
return uploaded && synced;
}
public boolean areTracksLoaded(Pair<Integer, Integer> item)
{
return sBundlesWithTracks.get(item.second) != null && item.first == Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE;
}
public boolean areTracksLoadingScheduled(Pair<Integer, Integer> item)
{
return sScheduledTracksLoading.contains(item);
}
/**
* Read the static breadcrumbs data from private file
*
* @param ctx
* @return is refresh is needed
*/
@SuppressWarnings("unchecked")
public boolean readCache(Context ctx)
{
FileInputStream fis = null;
ObjectInputStream ois = null;
Date bundlesPersisted = null, activitiesPersisted = null;
Object[] cache;
synchronized (BREADCRUMSB_BUNDLES_CACHE_FILE)
{
try
{
fis = ctx.openFileInput(BREADCRUMSB_BUNDLES_CACHE_FILE);
ois = new ObjectInputStream(fis);
cache = (Object[]) ois.readObject();
// new Object[] { CACHE_VERSION, new Date(), sActivitiesWithBundles, sBundlesWithTracks, sBundleMappings, sTrackMappings };
if (cache[0] instanceof Integer && CACHE_VERSION.equals(cache[0]))
{
bundlesPersisted = (Date) cache[1];
HashMap<Integer, List<Integer>> bundles = (HashMap<Integer, List<Integer>>) cache[2];
HashMap<Integer, Map<String, String>> bundlemappings = (HashMap<Integer, Map<String, String>>) cache[3];
HashMap<Integer, Map<String, String>> trackmappings = (HashMap<Integer, Map<String, String>>) cache[4];
sBundlesWithTracks = bundles != null ? bundles : sBundlesWithTracks;
sBundleMappings = bundlemappings != null ? bundlemappings : sBundleMappings;
sTrackMappings = trackmappings != null ? trackmappings : sTrackMappings;
}
else
{
clearPersistentCache(ctx);
}
fis = ctx.openFileInput(BREADCRUMSB_ACTIVITY_CACHE_FILE);
ois = new ObjectInputStream(fis);
cache = (Object[]) ois.readObject();
// new Object[] { CACHE_VERSION, new Date(), sActivityMappings };
if (cache[0] instanceof Integer && CACHE_VERSION.equals(cache[0]))
{
activitiesPersisted = (Date) cache[1];
HashMap<Integer, Map<String, String>> activitymappings = (HashMap<Integer, Map<String, String>>) cache[2];
sActivityMappings = activitymappings != null ? activitymappings : sActivityMappings;
}
else
{
clearPersistentCache(ctx);
}
}
catch (OptionalDataException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
catch (ClassNotFoundException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
catch (IOException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
catch (ClassCastException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
catch (ArrayIndexOutOfBoundsException e)
{
clearPersistentCache(ctx);
Log.w(TAG, "Unable to read persisted breadcrumbs cache", e);
}
finally
{
if (fis != null)
{
try
{
fis.close();
}
catch (IOException e)
{
Log.w(TAG, "Error closing file stream after reading cache", e);
}
}
if (ois != null)
{
try
{
ois.close();
}
catch (IOException e)
{
Log.w(TAG, "Error closing object stream after reading cache", e);
}
}
}
}
setChanged();
notifyObservers();
boolean refreshNeeded = false;
refreshNeeded = refreshNeeded || bundlesPersisted == null || activitiesPersisted == null;
refreshNeeded = refreshNeeded || (activitiesPersisted.getTime() < new Date().getTime() - CACHE_TIMEOUT * 10);
refreshNeeded = refreshNeeded || (bundlesPersisted.getTime() < new Date().getTime() - CACHE_TIMEOUT);
return refreshNeeded;
}
public void persistCache(Context ctx)
{
FileOutputStream fos = null;
ObjectOutputStream oos = null;
Object[] cache;
synchronized (BREADCRUMSB_BUNDLES_CACHE_FILE)
{
try
{
fos = ctx.openFileOutput(BREADCRUMSB_BUNDLES_CACHE_FILE, Context.MODE_PRIVATE);
oos = new ObjectOutputStream(fos);
cache = new Object[] { CACHE_VERSION, new Date(), sBundlesWithTracks, sBundleMappings, sTrackMappings };
oos.writeObject(cache);
fos = ctx.openFileOutput(BREADCRUMSB_ACTIVITY_CACHE_FILE, Context.MODE_PRIVATE);
oos = new ObjectOutputStream(fos);
cache = new Object[] { CACHE_VERSION, new Date(), sActivityMappings };
oos.writeObject(cache);
}
catch (FileNotFoundException e)
{
Log.e(TAG, "Error in file stream during persist cache", e);
}
catch (IOException e)
{
Log.e(TAG, "Error in object stream during persist cache", e);
}
finally
{
if (fos != null)
{
try
{
fos.close();
}
catch (IOException e)
{
Log.w(TAG, "Error closing file stream after writing cache", e);
}
}
if (oos != null)
{
try
{
oos.close();
}
catch (IOException e)
{
Log.w(TAG, "Error closing object stream after writing cache", e);
}
}
}
}
}
public void clearAllCache(Context ctx)
{
BreadcrumbsTracks.initCacheVariables();
setChanged();
clearPersistentCache(ctx);
notifyObservers();
}
public void clearPersistentCache(Context ctx)
{
Log.w(TAG, "Deleting old Breadcrumbs cache files");
synchronized (BREADCRUMSB_BUNDLES_CACHE_FILE)
{
ctx.deleteFile(BREADCRUMSB_ACTIVITY_CACHE_FILE);
ctx.deleteFile(BREADCRUMSB_BUNDLES_CACHE_FILE);
}
}
@Override
public String toString()
{
return "BreadcrumbsTracks [mActivityMappings=" + sActivityMappings + ", mBundleMappings=" + sBundleMappings + ", mTrackMappings=" + sTrackMappings
+ ", mActivities=" + sActivityMappings + ", mBundles=" + sBundlesWithTracks + "]";
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/adapter/BreadcrumbsTracks.java | Java | gpl3 | 23,924 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.adapter;
import java.util.LinkedList;
import java.util.List;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.tasks.GpxParser;
import nl.sogeti.android.gpstracker.breadcrumbs.BreadcrumbsService;
import nl.sogeti.android.gpstracker.breadcrumbs.BreadcrumbsTracks;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.Pair;
import android.app.Activity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.TextView;
/**
* Organizes Breadcrumbs tasks based on demands on the BaseAdapter functions
*
* @version $Id:$
* @author rene (c) Apr 24, 2011, Sogeti B.V.
*/
public class BreadcrumbsAdapter extends BaseAdapter
{
private static final String TAG = "OGT.BreadcrumbsAdapter";
public static final boolean DEBUG = false;
private Activity mContext;
private LayoutInflater mInflater;
private BreadcrumbsService mService;
private List<Pair<Integer, Integer>> breadcrumbItems = new LinkedList<Pair<Integer, Integer>>();
public BreadcrumbsAdapter(Activity ctx, BreadcrumbsService service)
{
super();
mContext = ctx;
mService = service;
mInflater = LayoutInflater.from(mContext);
}
public void setService(BreadcrumbsService service)
{
mService = service;
updateItemList();
}
/**
* Reloads the current list of known breadcrumb listview items
*
*/
public void updateItemList()
{
mContext.runOnUiThread(new Runnable()
{
@Override
public void run()
{
if (mService != null)
{
breadcrumbItems = mService.getAllItems();
notifyDataSetChanged();
}
}
});
}
/**
* @see android.widget.Adapter#getCount()
*/
@Override
public int getCount()
{
if (mService != null)
{
if (mService.isAuthorized())
{
return breadcrumbItems.size();
}
else
{
return 1;
}
}
else
{
return 0;
}
}
/**
* @see android.widget.Adapter#getItem(int)
*/
@Override
public Object getItem(int position)
{
if (mService.isAuthorized())
{
return breadcrumbItems.get(position);
}
else
{
return Constants.BREADCRUMBS_CONNECT;
}
}
/**
* @see android.widget.Adapter#getItemId(int)
*/
@Override
public long getItemId(int position)
{
return position;
}
/**
* @see android.widget.Adapter#getView(int, android.view.View, android.view.ViewGroup)
*/
@Override
public View getView(int position, View convertView, ViewGroup parent)
{
View view = null;
if (mService.isAuthorized())
{
int type = getItemViewType(position);
if (convertView == null)
{
switch (type)
{
case Constants.BREADCRUMBS_BUNDLE_ITEM_VIEW_TYPE:
view = mInflater.inflate(R.layout.breadcrumbs_bundle, null);
break;
case Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE:
view = mInflater.inflate(R.layout.breadcrumbs_track, null);
break;
default:
view = new TextView(null);
break;
}
}
else
{
view = convertView;
}
Pair<Integer, Integer> item = breadcrumbItems.get(position);
mService.willDisplayItem(item);
String name;
switch (type)
{
case Constants.BREADCRUMBS_BUNDLE_ITEM_VIEW_TYPE:
name = mService.getValueForItem((Pair<Integer, Integer>) item, BreadcrumbsTracks.NAME);
((TextView) view.findViewById(R.id.listitem_name)).setText(name);
break;
case Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE:
TextView nameView = (TextView) view.findViewById(R.id.listitem_name);
TextView dateView = (TextView) view.findViewById(R.id.listitem_from);
nameView.setText(mService.getValueForItem(item, BreadcrumbsTracks.NAME));
String dateString = mService.getValueForItem(item, BreadcrumbsTracks.ENDTIME);
if (dateString != null)
{
Long date = GpxParser.parseXmlDateTime(dateString);
dateView.setText(date.toString());
}
break;
default:
view = new TextView(null);
break;
}
}
else
{
if (convertView == null)
{
view = mInflater.inflate(R.layout.breadcrumbs_connect, null);
}
else
{
view = convertView;
}
((TextView) view).setText(R.string.breadcrumbs_connect);
}
return view;
}
@Override
public int getViewTypeCount()
{
int types = 4;
return types;
}
@Override
public int getItemViewType(int position)
{
if (mService.isAuthorized())
{
Pair<Integer, Integer> item = breadcrumbItems.get(position);
return item.first;
}
else
{
return Constants.BREADCRUMBS_CONNECT_ITEM_VIEW_TYPE;
}
}
@Override
public boolean areAllItemsEnabled()
{
return false;
};
@Override
public boolean isEnabled(int position)
{
int itemViewType = getItemViewType(position);
return itemViewType == Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE || itemViewType == Constants.BREADCRUMBS_CONNECT_ITEM_VIEW_TYPE;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/adapter/BreadcrumbsAdapter.java | Java | gpl3 | 7,386 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.adapter;
import java.util.LinkedHashMap;
import java.util.Map;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.util.Constants;
import android.content.Context;
import android.database.DataSetObserver;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Adapter;
import android.widget.ArrayAdapter;
import android.widget.BaseAdapter;
import android.widget.ListAdapter;
/**
* Combines multiple Adapters into a sectioned ListAdapter
*
* @version $Id:$
* @author rene (c) Apr 24, 2011, Sogeti B.V.
*/
public class SectionedListAdapter extends BaseAdapter
{
@SuppressWarnings("unused")
private static final String TAG = "OGT.SectionedListAdapter";
private Map<String, BaseAdapter> mSections;
private ArrayAdapter<String> mHeaders;
public SectionedListAdapter(Context ctx)
{
mHeaders = new ArrayAdapter<String>(ctx, R.layout.section_header);
mSections = new LinkedHashMap<String, BaseAdapter>();
}
public void addSection(String name, BaseAdapter adapter)
{
mHeaders.add(name);
mSections.put(name, adapter);
}
@Override
public void registerDataSetObserver(DataSetObserver observer)
{
super.registerDataSetObserver(observer);
for( Adapter adapter : mSections.values() )
{
adapter.registerDataSetObserver(observer);
}
}
@Override
public void unregisterDataSetObserver(DataSetObserver observer)
{
super.unregisterDataSetObserver(observer);
for( Adapter adapter : mSections.values() )
{
adapter.unregisterDataSetObserver(observer);
}
}
/*
* (non-Javadoc)
* @see android.widget.Adapter#getCount()
*/
@Override
public int getCount()
{
int count = 0;
for (Adapter adapter : mSections.values())
{
count += adapter.getCount() + 1;
}
return count;
}
/*
* (non-Javadoc)
* @see android.widget.Adapter#getItem(int)
*/
@Override
public Object getItem(int position)
{
int countDown = position;
Adapter adapter;
for (String section : mSections.keySet())
{
adapter = mSections.get(section);
if (countDown == 0)
{
return section;
}
countDown--;
if (countDown < adapter.getCount())
{
return adapter.getItem(countDown);
}
countDown -= adapter.getCount();
}
return null;
}
/*
* (non-Javadoc)
* @see android.widget.Adapter#getItemId(int)
*/
@Override
public long getItemId(int position)
{
int countDown = position;
Adapter adapter;
for (String section : mSections.keySet())
{
adapter = mSections.get(section);
if (countDown == 0)
{
return position;
}
countDown--;
if (countDown < adapter.getCount())
{
long id = adapter.getItemId(countDown);
return id;
}
countDown -= adapter.getCount();
}
return -1;
}
/*
* (non-Javadoc)
* @see android.widget.Adapter#getView(int, android.view.View,
* android.view.ViewGroup)
*/
@Override
public View getView(final int position, View convertView, ViewGroup parent)
{
int sectionNumber = 0;
int countDown = position;
for (String section : mSections.keySet())
{
Adapter adapter = mSections.get(section);
int size = adapter.getCount() + 1;
// check if position inside this section
if (countDown == 0)
{
return mHeaders.getView(sectionNumber, convertView, parent);
}
if (countDown < size)
{
return adapter.getView(countDown - 1, convertView, parent);
}
// otherwise jump into next section
countDown -= size;
sectionNumber++;
}
return null;
}
@Override
public int getViewTypeCount()
{
int types = 1;
for (Adapter section : mSections.values())
{
types += section.getViewTypeCount();
}
return types;
}
@Override
public int getItemViewType(int position)
{
int type = 1;
Adapter adapter;
int countDown = position;
for (String section : mSections.keySet())
{
adapter = mSections.get(section);
int size = adapter.getCount() + 1;
if (countDown == 0)
{
return Constants.SECTIONED_HEADER_ITEM_VIEW_TYPE;
}
else if (countDown < size)
{
return type + adapter.getItemViewType(countDown - 1);
}
countDown -= size;
type += adapter.getViewTypeCount();
}
return ListAdapter.IGNORE_ITEM_VIEW_TYPE;
}
@Override
public boolean areAllItemsEnabled()
{
return false;
};
@Override
public boolean isEnabled(int position)
{
if( getItemViewType(position) == Constants.SECTIONED_HEADER_ITEM_VIEW_TYPE )
{
return false;
}
else
{
int countDown = position;
for (String section : mSections.keySet())
{
BaseAdapter adapter = mSections.get(section);
countDown--;
int size = adapter.getCount() ;
if (countDown < size)
{
return adapter.isEnabled(countDown);
}
// otherwise jump into next section
countDown -= size;
}
}
return false ;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/adapter/SectionedListAdapter.java | Java | gpl3 | 7,170 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.util;
import java.text.DateFormat;
import java.util.Date;
import android.content.Context;
import android.util.AttributeSet;
import android.widget.TextView;
/**
* An implementation for the XML element DateView that alters the textview in the
* formating of the text when displaying a date in ms from 1970.
*
* @version $Id$
* @author rene (c) Jan 22, 2009, Sogeti B.V.
*/
public class DateView extends TextView
{
private Date mDate;
/**
* Constructor: create a new DateView.
* @param context
*/
public DateView(Context context)
{
super( context );
}
/**
* Constructor: create a new DateView.
* @param context
* @param attrs
*/
public DateView(Context context, AttributeSet attrs)
{
super( context, attrs );
}
/**
* Constructor: create a new DateView.
* @param context
* @param attrs
* @param defStyle
*/
public DateView(Context context, AttributeSet attrs, int defStyle)
{
super( context, attrs, defStyle );
}
/*
* (non-Javadoc)
* @see android.widget.TextView#setText(java.lang.CharSequence, android.widget.TextView.BufferType)
*/
@Override
public void setText( CharSequence charSeq, BufferType type )
{
// Behavior for the graphical editor
if( this.isInEditMode() )
{
super.setText( charSeq, type );
return;
}
long longVal;
if( charSeq.length() == 0 )
{
longVal = 0l ;
}
else
{
try
{
longVal = Long.parseLong(charSeq.toString()) ;
}
catch(NumberFormatException e)
{
longVal = 0l;
}
}
this.mDate = new Date( longVal );
DateFormat dateFormat = android.text.format.DateFormat.getLongDateFormat(this.getContext().getApplicationContext());
DateFormat timeFormat = android.text.format.DateFormat.getTimeFormat(this.getContext().getApplicationContext());
String text = timeFormat.format(this.mDate) + " " + dateFormat.format(mDate);
super.setText( text, type );
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/util/DateView.java | Java | gpl3 | 3,692 |
/* Copyright (c) 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package nl.sogeti.android.gpstracker.util;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PushbackInputStream;
import java.io.Reader;
public class UnicodeReader extends Reader
{
private static final int BOM_SIZE = 4;
private final InputStreamReader reader;
/**
* Construct UnicodeReader
*
* @param in Input stream.
* @param defaultEncoding Default encoding to be used if BOM is not found, or <code>null</code> to use system default encoding.
* @throws IOException If an I/O error occurs.
*/
public UnicodeReader(InputStream in, String defaultEncoding) throws IOException
{
byte bom[] = new byte[BOM_SIZE];
String encoding;
int unread;
PushbackInputStream pushbackStream = new PushbackInputStream( in, BOM_SIZE );
int n = pushbackStream.read( bom, 0, bom.length );
// Read ahead four bytes and check for BOM marks.
if( ( bom[0] == (byte) 0xEF ) && ( bom[1] == (byte) 0xBB ) && ( bom[2] == (byte) 0xBF ) )
{
encoding = "UTF-8";
unread = n - 3;
}
else if( ( bom[0] == (byte) 0xFE ) && ( bom[1] == (byte) 0xFF ) )
{
encoding = "UTF-16BE";
unread = n - 2;
}
else if( ( bom[0] == (byte) 0xFF ) && ( bom[1] == (byte) 0xFE ) )
{
encoding = "UTF-16LE";
unread = n - 2;
}
else if( ( bom[0] == (byte) 0x00 ) && ( bom[1] == (byte) 0x00 ) && ( bom[2] == (byte) 0xFE ) && ( bom[3] == (byte) 0xFF ) )
{
encoding = "UTF-32BE";
unread = n - 4;
}
else if( ( bom[0] == (byte) 0xFF ) && ( bom[1] == (byte) 0xFE ) && ( bom[2] == (byte) 0x00 ) && ( bom[3] == (byte) 0x00 ) )
{
encoding = "UTF-32LE";
unread = n - 4;
}
else
{
encoding = defaultEncoding;
unread = n;
}
// Unread bytes if necessary and skip BOM marks.
if( unread > 0 )
{
pushbackStream.unread( bom, ( n - unread ), unread );
}
else if( unread < -1 )
{
pushbackStream.unread( bom, 0, 0 );
}
// Use given encoding.
if( encoding == null )
{
reader = new InputStreamReader( pushbackStream );
}
else
{
reader = new InputStreamReader( pushbackStream, encoding );
}
}
public String getEncoding()
{
return reader.getEncoding();
}
@Override
public int read( char[] cbuf, int off, int len ) throws IOException
{
return reader.read( cbuf, off, len );
}
@Override
public void close() throws IOException
{
reader.close();
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/util/UnicodeReader.java | Java | gpl3 | 3,284 |
/*
* Written by Tom van Braeckel @ http://code.google.com/u/tomvanbraeckel/
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.util;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.preference.PreferenceManager;
import android.util.Log;
public class BootReceiver extends BroadcastReceiver
{
private final static String TAG = "OGT.BootReceiver";
@Override
public void onReceive( Context context, Intent intent )
{
// Log.d( TAG, "BootReceiver.onReceive(), probably ACTION_BOOT_COMPLETED" );
String action = intent.getAction();
// start on BOOT_COMPLETED
if( action.equals( Intent.ACTION_BOOT_COMPLETED ) )
{
// Log.d( TAG, "BootReceiver received ACTION_BOOT_COMPLETED" );
// check in the settings if we need to auto start
boolean startImmidiatly = PreferenceManager.getDefaultSharedPreferences( context ).getBoolean( Constants.STARTUPATBOOT, false );
if( startImmidiatly )
{
// Log.d( TAG, "Starting LoggerMap activity..." );
context.startService( new Intent( Constants.SERVICENAME ) );
}
else
{
Log.i( TAG, "Not starting Logger Service. Adjust the settings if you wanted this !" );
}
}
else
{
// this shouldn't happen !
Log.w( TAG, "OpenGPSTracker's BootReceiver received " + action + ", but it's only able to respond to " + Intent.ACTION_BOOT_COMPLETED + ". This shouldn't happen !" );
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/util/BootReceiver.java | Java | gpl3 | 2,288 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Mar 10, 2012 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*/
package nl.sogeti.android.gpstracker.util;
import nl.sogeti.android.gpstracker.R;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
/**
* ????
*
* @version $Id:$
* @author rene (c) Mar 10, 2012, Sogeti B.V.
*/
public class SlidingIndicatorView extends View
{
private static final String TAG = "OGT.SlidingIndicatorView";
private float mMinimum = 0;
private float mMaximum = 100 ;
private float mValue = 0;
private Drawable mIndicator;
private int mIntrinsicHeight;
public SlidingIndicatorView(Context context)
{
super(context);
}
public SlidingIndicatorView(Context context, AttributeSet attrs)
{
super(context, attrs);
}
public SlidingIndicatorView(Context context, AttributeSet attrs, int defStyle)
{
super(context, attrs, defStyle);
}
@Override
protected void onDraw(Canvas canvas)
{
super.onDraw(canvas);
if( mIndicator == null )
{
mIndicator = getResources().getDrawable(R.drawable.stip);
mIntrinsicHeight = mIndicator.getIntrinsicHeight();
mIndicator.setBounds(0, 0, getWidth(), mIntrinsicHeight);
}
int height = getHeight();
float scale = Math.abs( mValue/(mMaximum-mMinimum) );
float y = height - height*scale;
float translate = y-mIntrinsicHeight;
canvas.save();
canvas.translate(0, translate);
mIndicator.draw(canvas);
canvas.restore();
}
public float getMin()
{
return mMinimum;
}
public void setMin(float min)
{
if(mMaximum-mMinimum == 0 )
{
Log.w(TAG, "Minimum and maximum difference must be greater then 0");
return;
}
this.mMinimum = min;
}
public float getMax()
{
return mMaximum;
}
public void setMax(float max)
{
if(mMaximum-mMinimum == 0 )
{
Log.w(TAG, "Minimum and maximum difference must be greater then 0");
return;
}
this.mMaximum = max;
}
public float getValue()
{
return mValue;
}
public void setValue(float value)
{
this.mValue = value;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/util/SlidingIndicatorView.java | Java | gpl3 | 3,065 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.util;
import nl.sogeti.android.gpstracker.logger.GPSLoggerService;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.util.Log;
public class DockReceiver extends BroadcastReceiver
{
private final static String TAG = "OGT.DockReceiver";
@Override
public void onReceive( Context context, Intent intent )
{
String action = intent.getAction();
if( action.equals( Intent.ACTION_DOCK_EVENT ) )
{
Bundle extras = intent.getExtras();
boolean start = false;
boolean stop = false;
if( extras != null && extras.containsKey(Intent.EXTRA_DOCK_STATE ) )
{
int dockstate = extras.getInt(Intent.EXTRA_DOCK_STATE, -1);
if( dockstate == Intent.EXTRA_DOCK_STATE_CAR )
{
start = PreferenceManager.getDefaultSharedPreferences( context ).getBoolean( Constants.LOGATDOCK, false );
}
else if( dockstate == Intent.EXTRA_DOCK_STATE_UNDOCKED )
{
stop = PreferenceManager.getDefaultSharedPreferences( context ).getBoolean( Constants.STOPATUNDOCK, false );
}
}
if( start )
{
Intent serviceIntent = new Intent( Constants.SERVICENAME );
serviceIntent.putExtra(GPSLoggerService.COMMAND, GPSLoggerService.EXTRA_COMMAND_START);
context.startService( serviceIntent );
}
else if( stop )
{
Intent serviceIntent = new Intent( Constants.SERVICENAME );
serviceIntent.putExtra(GPSLoggerService.COMMAND, GPSLoggerService.EXTRA_COMMAND_STOP);
context.startService( serviceIntent );
}
}
else
{
Log.w( TAG, "OpenGPSTracker's BootReceiver received " + action + ", but it's only able to respond to " + Intent.ACTION_BOOT_COMPLETED + ". This shouldn't happen !" );
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/util/DockReceiver.java | Java | gpl3 | 3,584 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.util;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import nl.sogeti.android.gpstracker.actions.tasks.GpxParser;
import nl.sogeti.android.gpstracker.actions.tasks.GpxParser.ProgressAdmin;
/**
* ????
*
* @version $Id$
* @author rene (c) Dec 11, 2010, Sogeti B.V.
*/
public class ProgressFilterInputStream extends FilterInputStream
{
GpxParser mAsyncTask;
long progress = 0;
private ProgressAdmin mProgressAdmin;
public ProgressFilterInputStream(InputStream is, ProgressAdmin progressAdmin)
{
super( is );
mProgressAdmin = progressAdmin;
}
@Override
public int read() throws IOException
{
int read = super.read();
incrementProgressBy( 1 );
return read;
}
@Override
public int read( byte[] buffer, int offset, int count ) throws IOException
{
int read = super.read( buffer, offset, count );
incrementProgressBy( read );
return read;
}
private void incrementProgressBy( int bytes )
{
if( bytes > 0 )
{
mProgressAdmin.addBytesProgress(bytes);
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/util/ProgressFilterInputStream.java | Java | gpl3 | 2,694 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.util;
import java.util.Locale;
import nl.sogeti.android.gpstracker.R;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.preference.PreferenceManager;
import android.util.TypedValue;
/**
* Collection of methods to provide metric and imperial data based on locale or
* overridden by configuration
*
* @version $Id$
* @author rene (c) Feb 2, 2010, Sogeti B.V.
*/
public class UnitsI18n
{
private Context mContext;
private double mConversion_from_mps_to_speed;
private double mConversion_from_meter_to_distance;
private double mConversion_from_meter_to_height;
private String mSpeed_unit;
private String mDistance_unit;
private String mHeight_unit;
private UnitsChangeListener mListener;
private OnSharedPreferenceChangeListener mPreferenceListener = new OnSharedPreferenceChangeListener()
{
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
{
if (key.equals(Constants.UNITS))
{
initBasedOnPreferences(sharedPreferences);
if (mListener != null)
{
mListener.onUnitsChange();
}
}
}
};
private boolean needsUnitFlip;
private int mUnits;
@SuppressWarnings("unused")
private static final String TAG = "OGT.UnitsI18n";
public UnitsI18n(Context ctx, UnitsChangeListener listener)
{
this(ctx);
mListener = listener;
}
public UnitsI18n(Context ctx)
{
mContext = ctx;
initBasedOnPreferences(PreferenceManager.getDefaultSharedPreferences(mContext));
}
private void initBasedOnPreferences(SharedPreferences sharedPreferences)
{
mUnits = Integer.parseInt(sharedPreferences.getString(Constants.UNITS, Integer.toString(Constants.UNITS_DEFAULT)));
switch (mUnits)
{
case (Constants.UNITS_DEFAULT):
setToDefault();
break;
case (Constants.UNITS_IMPERIAL):
setToImperial();
break;
case (Constants.UNITS_METRIC):
setToMetric();
break;
case (Constants.UNITS_NAUTIC):
setToMetric();
overrideWithNautic(mContext.getResources());
break;
case (Constants.UNITS_METRICPACE):
setToMetric();
overrideWithPace(mContext.getResources());
break;
case (Constants.UNITS_IMPERIALPACE):
setToImperial();
overrideWithPaceImperial(mContext.getResources());
break;
case Constants.UNITS_IMPERIALSURFACE:
setToImperial();
overrideWithSurfaceImperial();
break;
case Constants.UNITS_METRICSURFACE:
setToMetric();
overrideWithSurfaceMetric();
break;
default:
setToDefault();
break;
}
}
private void setToDefault()
{
Resources resources = mContext.getResources();
init(resources);
}
private void setToMetric()
{
Resources resources = mContext.getResources();
Configuration config = resources.getConfiguration();
Locale oldLocale = config.locale;
config.locale = new Locale("");
resources.updateConfiguration(config, resources.getDisplayMetrics());
init(resources);
config.locale = oldLocale;
resources.updateConfiguration(config, resources.getDisplayMetrics());
}
private void setToImperial()
{
Resources resources = mContext.getResources();
Configuration config = resources.getConfiguration();
Locale oldLocale = config.locale;
config.locale = Locale.US;
resources.updateConfiguration(config, resources.getDisplayMetrics());
init(resources);
config.locale = oldLocale;
resources.updateConfiguration(config, resources.getDisplayMetrics());
}
/**
* Based on a given Locale prefetch the units conversions and names.
*
* @param resources Resources initialized with a Locale
*/
private void init(Resources resources)
{
TypedValue outValue = new TypedValue();
needsUnitFlip = false;
resources.getValue(R.raw.conversion_from_mps, outValue, false);
mConversion_from_mps_to_speed = outValue.getFloat();
resources.getValue(R.raw.conversion_from_meter, outValue, false);
mConversion_from_meter_to_distance = outValue.getFloat();
resources.getValue(R.raw.conversion_from_meter_to_height, outValue, false);
mConversion_from_meter_to_height = outValue.getFloat();
mSpeed_unit = resources.getString(R.string.speed_unitname);
mDistance_unit = resources.getString(R.string.distance_unitname);
mHeight_unit = resources.getString(R.string.distance_smallunitname);
}
private void overrideWithNautic(Resources resources)
{
TypedValue outValue = new TypedValue();
resources.getValue(R.raw.conversion_from_mps_to_knot, outValue, false);
mConversion_from_mps_to_speed = outValue.getFloat();
resources.getValue(R.raw.conversion_from_meter_to_nauticmile, outValue, false);
mConversion_from_meter_to_distance = outValue.getFloat();
mSpeed_unit = resources.getString(R.string.knot_unitname);
mDistance_unit = resources.getString(R.string.nautic_unitname);
}
private void overrideWithPace(Resources resources)
{
needsUnitFlip = true;
mSpeed_unit = resources.getString(R.string.pace_unitname);
}
private void overrideWithPaceImperial(Resources resources)
{
needsUnitFlip = true;
mSpeed_unit = resources.getString(R.string.pace_unitname_imperial);
}
private void overrideWithSurfaceImperial()
{
float width = getWidthPreference();
Resources resources = mContext.getResources();
TypedValue outValue = new TypedValue();
resources.getValue(R.raw.conversion_from_mps_to_acres_hour, outValue, false);
mConversion_from_mps_to_speed = outValue.getFloat() * width;
mSpeed_unit = resources.getString(R.string.surface_unitname_imperial);
}
private float getWidthPreference()
{
return Float.parseFloat(PreferenceManager.getDefaultSharedPreferences(mContext).getString("units_implement_width", "12"));
}
private void overrideWithSurfaceMetric()
{
float width = getWidthPreference();
Resources resources = mContext.getResources();
TypedValue outValue = new TypedValue();
resources.getValue(R.raw.conversion_from_mps_to_hectare_hour, outValue, false);
mConversion_from_mps_to_speed = outValue.getFloat() * width;
mSpeed_unit = resources.getString(R.string.surface_unitname_metric);
}
public double conversionFromMeterAndMiliseconds(double meters, long miliseconds)
{
float seconds = miliseconds / 1000f;
return conversionFromMetersPerSecond(meters / seconds);
}
public double conversionFromMetersPerSecond(double mps)
{
double speed = mps * mConversion_from_mps_to_speed;
if (needsUnitFlip) // Flip from "x per hour" to "minutes per x"
{
if (speed > 1) // Nearly no speed return 0 as if there is no speed
{
speed = (1 / speed) * 60.0;
}
else
{
speed = 0;
}
}
return speed;
}
public double conversionFromMeter(double meters)
{
double value = meters * mConversion_from_meter_to_distance;
return value;
}
public double conversionFromLocalToMeters(double localizedValue)
{
double meters = localizedValue / mConversion_from_meter_to_distance;
return meters;
}
public double conversionFromMeterToHeight(double meters)
{
return meters * mConversion_from_meter_to_height;
}
public String getSpeedUnit()
{
return mSpeed_unit;
}
public String getDistanceUnit()
{
return mDistance_unit;
}
public String getHeightUnit()
{
return mHeight_unit;
}
public boolean isUnitFlipped()
{
return needsUnitFlip;
}
public void setUnitsChangeListener(UnitsChangeListener unitsChangeListener)
{
mListener = unitsChangeListener;
if( mListener != null )
{
initBasedOnPreferences(PreferenceManager.getDefaultSharedPreferences(mContext));
PreferenceManager.getDefaultSharedPreferences(mContext).registerOnSharedPreferenceChangeListener(mPreferenceListener);
}
else
{
PreferenceManager.getDefaultSharedPreferences(mContext).unregisterOnSharedPreferenceChangeListener(mPreferenceListener);
}
}
/**
* Interface definition for a callback to be invoked when the preference for
* units changed.
*
* @version $Id$
* @author rene (c) Feb 14, 2010, Sogeti B.V.
*/
public interface UnitsChangeListener
{
/**
* Called when the unit data has changed.
*/
void onUnitsChange();
}
/**
* Format a speed using the current unit and flipping
*
* @param speed
* @param decimals format a bit larger showing decimals or seconds
* @return
*/
public String formatSpeed(double speed, boolean decimals)
{
String speedText;
if(mUnits == Constants.UNITS_METRICPACE || mUnits == Constants.UNITS_IMPERIALPACE)
{
if( decimals )
{
speedText = String.format( "%02d %s",
(int)speed,
this.getSpeedUnit() );
}
else
{
speedText = String.format( "%02d:%02d %s",
(int)speed,
(int)((speed-(int)speed)*60), // convert decimal to seconds
this.getSpeedUnit() );
}
}
else
{
if( decimals )
{
speedText = String.format( "%.2f %s", speed, this.getSpeedUnit() );
}
else
{
speedText = String.format( "%.0f %s", speed, this.getSpeedUnit() );
}
}
return speedText;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/util/UnitsI18n.java | Java | gpl3 | 11,781 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.util;
import java.io.File;
import nl.sogeti.android.gpstracker.db.GPStracking;
import android.content.Context;
import android.net.Uri;
import android.os.Environment;
import android.preference.PreferenceManager;
/**
* Various application wide constants
*
* @version $Id$
* @author rene (c) Mar 22, 2009, Sogeti B.V.
*/
public class Constants
{
public static final String DISABLEBLANKING = "disableblanking";
public static final String DISABLEDIMMING = "disabledimming";
public static final String SATELLITE = "SATELLITE";
public static final String TRAFFIC = "TRAFFIC";
public static final String SPEED = "showspeed";
public static final String ALTITUDE = "showaltitude";
public static final String DISTANCE = "showdistance";
public static final String COMPASS = "COMPASS";
public static final String LOCATION = "LOCATION";
public static final String MAPPROVIDER = "mapprovider";
public static final String TRACKCOLORING = "trackcoloring";
public static final String SPEEDSANITYCHECK = "speedsanitycheck";
public static final String PRECISION = "precision";
public static final String LOGATSTARTUP = "logatstartup";
public static final String STARTUPATBOOT = "startupatboot";
public static final String LOGATDOCK = "logatdock";
public static final String STOPATUNDOCK = "stopatundock";
public static final String SERVICENAME = "nl.sogeti.android.gpstracker.intent.action.GPSLoggerService";
public static final String STREAMBROADCAST = "nl.sogeti.android.gpstracker.intent.action.STREAMBROADCAST";
public static final String UNITS = "units";
public static final int UNITS_DEFAULT = 0;
public static final int UNITS_IMPERIAL = 1;
public static final int UNITS_METRIC = 2;
public static final int UNITS_NAUTIC = 3;
public static final int UNITS_METRICPACE = 4;
public static final int UNITS_IMPERIALPACE = 5;
public static final int UNITS_IMPERIALSURFACE = 6;
public static final int UNITS_METRICSURFACE = 7;
public static final String SDDIR_DIR = "SDDIR_DIR";
public static final String DEFAULT_EXTERNAL_DIR = "/OpenGPSTracker/";
public static final String TMPICTUREFILE_SUBPATH = "media_tmp.tmp";
public static final Uri NAME_URI = Uri.parse( "content://" + GPStracking.AUTHORITY+".string" );
public static final int GOOGLE = 0;
public static final int OSM = 1;
public static final int MAPQUEST = 2;
public static final String JOGRUNNER_AUTH = "JOGRUNNER_AUTH";
public static final String EXPORT_TYPE = "SHARE_TYPE";
public static final String EXPORT_GPXTARGET = "EXPORT_GPXTARGET";
public static final String EXPORT_KMZTARGET = "EXPORT_KMZTARGET";
public static final String EXPORT_TXTTARGET = "EXPORT_TXTTARGET";
public static final double MIN_STATISTICS_SPEED = 1.0d;
public static final int OSM_CLOUDMADE = 0;
public static final int OSM_MAKNIK = 1;
public static final int OSM_CYCLE = 2;
public static final String OSMBASEOVERLAY = "OSM_BASE_OVERLAY";
public static final String LOGGING_INTERVAL = "customprecisiontime";
public static final String LOGGING_DISTANCE = "customprecisiondistance";
public static final String STATUS_MONITOR = "gpsstatusmonitor";
public static final String OSM_USERNAME = "OSM_USERNAME";
public static final String OSM_PASSWORD = "OSM_PASSWORD";
public static final String OSM_VISIBILITY = "OSM_VISIBILITY";
public static final String DATASOURCES_KEY = "DATASOURCES";
/**
* Broadcast intent action indicating that the logger service state has
* changed. Includes the logging state and its precision.
*
* @see #EXTRA_LOGGING_PRECISION
* @see #EXTRA_LOGGING_STATE
*/
public static final String LOGGING_STATE_CHANGED_ACTION = "nl.sogeti.android.gpstracker.LOGGING_STATE_CHANGED";
/**
* The precision the service is logging on.
*
* @see #LOGGING_FINE
* @see #LOGGING_NORMAL
* @see #LOGGING_COARSE
* @see #LOGGING_GLOBAL
* @see #LOGGING_CUSTOM
*
*/
public static final String EXTRA_LOGGING_PRECISION = "nl.sogeti.android.gpstracker.EXTRA_LOGGING_PRECISION";
/**
* The state the service is.
*
* @see #UNKNOWN
* @see #LOGGING
* @see #PAUSED
* @see #STOPPED
*/
public static final String EXTRA_LOGGING_STATE = "nl.sogeti.android.gpstracker.EXTRA_LOGGING_STATE";
/**
* The state of the service is unknown
*/
public static final int UNKNOWN = -1;
/**
* The service is actively logging, it has requested location update from the location provider.
*/
public static final int LOGGING = 1;
/**
* The service is not active, but can be resumed to become active and store location changes as
* part of a new segment of the current track.
*/
public static final int PAUSED = 2;
/**
* The service is not active and can not resume a current track but must start a new one when becoming active.
*/
public static final int STOPPED = 3;
/**
* The precision of the GPS provider is based on the custom time interval and distance.
*/
public static final int LOGGING_CUSTOM = 0;
/**
* The GPS location provider is asked to update every 10 seconds or every 5 meters.
*/
public static final int LOGGING_FINE = 1;
/**
* The GPS location provider is asked to update every 15 seconds or every 10 meters.
*/
public static final int LOGGING_NORMAL = 2;
/**
* The GPS location provider is asked to update every 30 seconds or every 25 meters.
*/
public static final int LOGGING_COARSE = 3;
/**
* The radio location provider is asked to update every 5 minutes or every 500 meters.
*/
public static final int LOGGING_GLOBAL = 4;
public static final String REQUEST_URL = "http://api.gobreadcrumbs.com/oauth/request_token";
public static final String ACCESS_URL = "http://api.gobreadcrumbs.com/oauth/access_token";
public static final String AUTHORIZE_URL = "http://api.gobreadcrumbs.com/oauth/authorize";
public static final String OSM_REQUEST_URL = "http://www.openstreetmap.org/oauth/request_token";
public static final String OSM_ACCESS_URL = "http://www.openstreetmap.org/oauth/access_token";
public static final String OSM_AUTHORIZE_URL = "http://www.openstreetmap.org/oauth/authorize";
public static final String OAUTH_CALLBACK_SCHEME = "x-oauthflow-opengpstracker";
public static final String OAUTH_CALLBACK_HOST = "callback";
public static final String OAUTH_CALLBACK_URL = OAUTH_CALLBACK_SCHEME + "://" + OAUTH_CALLBACK_HOST;
public static final String NAME = "NAME";
/**
* Based on preference return the SD-Card directory in which Open GPS Tracker creates and stores files
* shared tracks,
*
* @param ctx
* @return
*/
public static String getSdCardDirectory( Context ctx )
{
// Read preference and ensure start and end with '/' symbol
String dir = PreferenceManager.getDefaultSharedPreferences(ctx).getString(SDDIR_DIR, DEFAULT_EXTERNAL_DIR);
if( !dir.startsWith("/") )
{
dir = "/" + dir;
}
if( !dir.endsWith("/") )
{
dir = dir + "/" ;
}
dir = Environment.getExternalStorageDirectory().getAbsolutePath() + dir;
// If neither exists or can be created fall back to default
File dirHandle = new File(dir);
if( !dirHandle.exists() && !dirHandle.mkdirs() )
{
dir = Environment.getExternalStorageDirectory().getAbsolutePath() + DEFAULT_EXTERNAL_DIR;
}
return dir;
}
public static String getSdCardTmpFile( Context ctx )
{
String dir = getSdCardDirectory( ctx ) + TMPICTUREFILE_SUBPATH;
return dir;
}
public static final String BREADCRUMBS_CONNECT = "breadcrumbs_connect";
public static final int BREADCRUMBS_CONNECT_ITEM_VIEW_TYPE = 0;
public static final int BREADCRUMBS_BUNDLE_ITEM_VIEW_TYPE = 2;
public static final int BREADCRUMBS_TRACK_ITEM_VIEW_TYPE = 3;
public static final int BREADCRUMBS_ACTIVITY_ITEM_VIEW_TYPE = 4;
public static final int SECTIONED_HEADER_ITEM_VIEW_TYPE = 0;
public static final String BROADCAST_STREAM = "STREAM_ENABLED";
/**
* A distance in meters
*/
public static final String EXTRA_DISTANCE = "nl.sogeti.android.gpstracker.EXTRA_DISTANCE";
/**
* A time period in minutes
*/
public static final String EXTRA_TIME = "nl.sogeti.android.gpstracker.EXTRA_TIME";
/**
* The location that pushed beyond the set minimum time or distance
*/
public static final String EXTRA_LOCATION = "nl.sogeti.android.gpstracker.EXTRA_LOCATION";
/**
* The track that is being logged
*/
public static final String EXTRA_TRACK = "nl.sogeti.android.gpstracker.EXTRA_TRACK";
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/util/Constants.java | Java | gpl3 | 10,472 |
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package nl.sogeti.android.gpstracker.util;
/**
* Container to ease passing around a tuple of two objects. This object provides a sensible
* implementation of equals(), returning true if equals() is true on each of the contained
* objects.
*/
public class Pair<F, S> {
public final F first;
public final S second;
private String toStringOverride;
/**
* Constructor for a Pair. If either are null then equals() and hashCode() will throw
* a NullPointerException.
* @param first the first object in the Pair
* @param second the second object in the pair
*/
public Pair(F first, S second) {
this.first = first;
this.second = second;
}
/**
* Checks the two objects for equality by delegating to their respective equals() methods.
* @param o the Pair to which this one is to be checked for equality
* @return true if the underlying objects of the Pair are both considered equals()
*/
@SuppressWarnings("unchecked")
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Pair)) return false;
final Pair<F, S> other;
try {
other = (Pair<F, S>) o;
} catch (ClassCastException e) {
return false;
}
return first.equals(other.first) && second.equals(other.second);
}
/**
* Compute a hash code using the hash codes of the underlying objects
* @return a hashcode of the Pair
*/
@Override
public int hashCode() {
int result = 17;
result = 31 * result + first.hashCode();
result = 31 * result + second.hashCode();
return result;
}
/**
* Convenience method for creating an appropriately typed pair.
* @param a the first object in the Pair
* @param b the second object in the pair
* @return a Pair that is templatized with the types of a and b
*/
public static <A, B> Pair <A, B> create(A a, B b) {
return new Pair<A, B>(a, b);
}
public void overrideToString(String toStringOverride)
{
this.toStringOverride = toStringOverride;
}
@Override
public String toString()
{
if( toStringOverride == null )
{
return super.toString();
}
else
{
return toStringOverride;
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/util/Pair.java | Java | gpl3 | 2,988 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Feb 25, 2012 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*/
package nl.sogeti.android.gpstracker.viewer;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import nl.sogeti.android.gpstracker.R;
import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Bundle;
import android.util.Log;
import android.webkit.WebView;
import android.widget.TextView;
/**
* ????
*
* @version $Id:$
* @author rene (c) Feb 25, 2012, Sogeti B.V.
*/
public class About extends Activity
{
private static final String TAG = "OGT.About";
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.about);
fillContentFields();
}
private void fillContentFields()
{
TextView version = (TextView) findViewById(R.id.version);
try
{
version.setText(getPackageManager().getPackageInfo(getPackageName(), 0).versionName);
}
catch (NameNotFoundException e)
{
version.setText("");
}
WebView license = (WebView) findViewById(R.id.license_body);
license.loadUrl("file:///android_asset/license_short.html");
WebView contributions = (WebView) findViewById(R.id.contribution_body);
contributions.loadUrl("file:///android_asset/contributions.html");
WebView notice = (WebView) findViewById(R.id.notices_body);
notice.loadUrl("file:///android_asset/notices.html");
}
public static String readRawTextFile(Context ctx, int resId)
{
InputStream inputStream = ctx.getResources().openRawResource(resId);
InputStreamReader inputreader = new InputStreamReader(inputStream);
BufferedReader buffreader = new BufferedReader(inputreader);
String line;
StringBuilder text = new StringBuilder();
try
{
while ((line = buffreader.readLine()) != null)
{
text.append(line);
text.append('\n');
}
}
catch (IOException e)
{
Log.e(TAG, "Failed to read raw text resource", e);
}
return text.toString();
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/About.java | Java | gpl3 | 2,985 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.viewer.map;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.SlidingIndicatorView;
import nl.sogeti.android.gpstracker.viewer.map.overlay.FixedMyLocationOverlay;
import nl.sogeti.android.gpstracker.viewer.map.overlay.OverlayProvider;
import android.app.Activity;
import android.app.Dialog;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.graphics.Bitmap;
import android.graphics.Point;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.BaseAdapter;
import android.widget.TextView;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapActivity;
import com.google.android.maps.MapView;
/**
* Main activity showing a track and allowing logging control
*
* @version $Id$
* @author rene (c) Jan 18, 2009, Sogeti B.V.
*/
public class GoogleLoggerMap extends MapActivity implements LoggerMap
{
LoggerMapHelper mHelper;
private MapView mMapView;
private TextView[] mSpeedtexts;
private TextView mLastGPSSpeedView;
private TextView mLastGPSAltitudeView;
private TextView mDistanceView;
private FixedMyLocationOverlay mMylocation;
/**
* Called when the activity is first created.
*/
@Override
protected void onCreate(Bundle load)
{
super.onCreate(load);
setContentView(R.layout.map_google);
mHelper = new LoggerMapHelper(this);
mMapView = (MapView) findViewById(R.id.myMapView);
mMylocation = new FixedMyLocationOverlay(this, mMapView);
mMapView.setBuiltInZoomControls(true);
TextView[] speeds = { (TextView) findViewById(R.id.speedview05), (TextView) findViewById(R.id.speedview04), (TextView) findViewById(R.id.speedview03),
(TextView) findViewById(R.id.speedview02), (TextView) findViewById(R.id.speedview01), (TextView) findViewById(R.id.speedview00) };
mSpeedtexts = speeds;
mLastGPSSpeedView = (TextView) findViewById(R.id.currentSpeed);
mLastGPSAltitudeView = (TextView) findViewById(R.id.currentAltitude);
mDistanceView = (TextView) findViewById(R.id.currentDistance);
mHelper.onCreate(load);
}
@Override
protected void onResume()
{
super.onResume();
mHelper.onResume();
}
@Override
protected void onPause()
{
mHelper.onPause();
super.onPause();
}
@Override
protected void onDestroy()
{
mHelper.onDestroy();
super.onDestroy();
}
@Override
public void onNewIntent(Intent newIntent)
{
mHelper.onNewIntent(newIntent);
}
@Override
protected void onRestoreInstanceState(Bundle load)
{
if (load != null)
{
super.onRestoreInstanceState(load);
}
mHelper.onRestoreInstanceState(load);
}
@Override
protected void onSaveInstanceState(Bundle save)
{
super.onSaveInstanceState(save);
mHelper.onSaveInstanceState(save);
}
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
boolean result = super.onCreateOptionsMenu(menu);
mHelper.onCreateOptionsMenu(menu);
return result;
}
@Override
public boolean onPrepareOptionsMenu(Menu menu)
{
mHelper.onPrepareOptionsMenu(menu);
return super.onPrepareOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item)
{
boolean handled = mHelper.onOptionsItemSelected(item);
if( !handled )
{
handled = super.onOptionsItemSelected(item);
}
return handled;
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent intent)
{
super.onActivityResult(requestCode, resultCode, intent);
mHelper.onActivityResult(requestCode, resultCode, intent);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event)
{
boolean propagate = true;
switch (keyCode)
{
case KeyEvent.KEYCODE_S:
setSatelliteOverlay(!this.mMapView.isSatellite());
propagate = false;
break;
case KeyEvent.KEYCODE_A:
setTrafficOverlay(!this.mMapView.isTraffic());
propagate = false;
break;
default:
propagate = mHelper.onKeyDown(keyCode, event);
if( propagate )
{
propagate = super.onKeyDown(keyCode, event);
}
break;
}
return propagate;
}
@Override
protected Dialog onCreateDialog(int id)
{
Dialog dialog = mHelper.onCreateDialog(id);
if( dialog == null )
{
dialog = super.onCreateDialog(id);
}
return dialog;
}
@Override
protected void onPrepareDialog(int id, Dialog dialog)
{
mHelper.onPrepareDialog(id, dialog);
super.onPrepareDialog(id, dialog);
}
/******************************/
/** Own methods **/
/******************************/
private void setTrafficOverlay(boolean b)
{
SharedPreferences sharedPreferences = mHelper.getPreferences();
Editor editor = sharedPreferences.edit();
editor.putBoolean(Constants.TRAFFIC, b);
editor.commit();
}
private void setSatelliteOverlay(boolean b)
{
SharedPreferences sharedPreferences = mHelper.getPreferences();
Editor editor = sharedPreferences.edit();
editor.putBoolean(Constants.SATELLITE, b);
editor.commit();
}
@Override
protected boolean isRouteDisplayed()
{
return true;
}
@Override
protected boolean isLocationDisplayed()
{
SharedPreferences sharedPreferences = mHelper.getPreferences();
return sharedPreferences.getBoolean(Constants.LOCATION, false) || mHelper.isLogging();
}
/******************************/
/** Loggermap methods **/
/******************************/
@Override
public void updateOverlays()
{
SharedPreferences sharedPreferences = mHelper.getPreferences();
GoogleLoggerMap.this.mMapView.setSatellite(sharedPreferences.getBoolean(Constants.SATELLITE, false));
GoogleLoggerMap.this.mMapView.setTraffic(sharedPreferences.getBoolean(Constants.TRAFFIC, false));
}
@Override
public void setDrawingCacheEnabled(boolean b)
{
findViewById(R.id.mapScreen).setDrawingCacheEnabled(true);
}
@Override
public Activity getActivity()
{
return this;
}
@Override
public void onLayerCheckedChanged(int checkedId, boolean isChecked)
{
switch (checkedId)
{
case R.id.layer_google_satellite:
setSatelliteOverlay(true);
break;
case R.id.layer_google_regular:
setSatelliteOverlay(false);
break;
case R.id.layer_traffic:
setTrafficOverlay(isChecked);
break;
default:
break;
}
}
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
{
if (key.equals(Constants.TRAFFIC))
{
updateOverlays();
}
else if (key.equals(Constants.SATELLITE))
{
updateOverlays();
}
}
@Override
public Bitmap getDrawingCache()
{
return findViewById(R.id.mapScreen).getDrawingCache();
}
@Override
public void showMediaDialog(BaseAdapter mediaAdapter)
{
mHelper.showMediaDialog(mediaAdapter);
}
public void onDateOverlayChanged()
{
mMapView.postInvalidate();
}
@Override
public String getDataSourceId()
{
return LoggerMapHelper.GOOGLE_PROVIDER;
}
@Override
public boolean isOutsideScreen(GeoPoint lastPoint)
{
Point out = new Point();
this.mMapView.getProjection().toPixels(lastPoint, out);
int height = this.mMapView.getHeight();
int width = this.mMapView.getWidth();
return (out.x < 0 || out.y < 0 || out.y > height || out.x > width);
}
@Override
public boolean isNearScreenEdge(GeoPoint lastPoint)
{
Point out = new Point();
this.mMapView.getProjection().toPixels(lastPoint, out);
int height = this.mMapView.getHeight();
int width = this.mMapView.getWidth();
return (out.x < width / 4 || out.y < height / 4 || out.x > (width / 4) * 3 || out.y > (height / 4) * 3);
}
@Override
public void executePostponedActions()
{
// NOOP for Google Maps
}
@Override
public void enableCompass()
{
mMylocation.enableCompass();
}
@Override
public void enableMyLocation()
{
mMylocation.enableMyLocation();
}
@Override
public void disableMyLocation()
{
mMylocation.disableMyLocation();
}
@Override
public void disableCompass()
{
mMylocation.disableCompass();
}
@Override
public void setZoom(int zoom)
{
mMapView.getController().setZoom(zoom);
}
@Override
public void animateTo(GeoPoint storedPoint)
{
mMapView.getController().animateTo(storedPoint);
}
@Override
public int getZoomLevel()
{
return mMapView.getZoomLevel();
}
@Override
public GeoPoint getMapCenter()
{
return mMapView.getMapCenter();
}
@Override
public boolean zoomOut()
{
return mMapView.getController().zoomOut();
}
@Override
public boolean zoomIn()
{
return mMapView.getController().zoomIn();
}
@Override
public void postInvalidate()
{
mMapView.postInvalidate();
}
@Override
public void clearAnimation()
{
mMapView.clearAnimation();
}
@Override
public void setCenter(GeoPoint lastPoint)
{
mMapView.getController().setCenter(lastPoint);
}
@Override
public int getMaxZoomLevel()
{
return mMapView.getMaxZoomLevel();
}
@Override
public GeoPoint fromPixels(int x, int y)
{
return mMapView.getProjection().fromPixels(x, y);
}
@Override
public boolean hasProjection()
{
return mMapView.getProjection() != null;
}
@Override
public float metersToEquatorPixels(float float1)
{
return mMapView.getProjection().metersToEquatorPixels(float1);
}
@Override
public void toPixels(GeoPoint geoPoint, Point screenPoint)
{
mMapView.getProjection().toPixels(geoPoint, screenPoint);
}
@Override
public TextView[] getSpeedTextViews()
{
return mSpeedtexts;
}
@Override
public TextView getAltitideTextView()
{
return mLastGPSAltitudeView;
}
@Override
public TextView getSpeedTextView()
{
return mLastGPSSpeedView;
}
@Override
public TextView getDistanceTextView()
{
return mDistanceView;
}
@Override
public void addOverlay(OverlayProvider overlay)
{
mMapView.getOverlays().add(overlay.getGoogleOverlay());
}
@Override
public void clearOverlays()
{
mMapView.getOverlays().clear();
}
@Override
public SlidingIndicatorView getScaleIndicatorView()
{
return (SlidingIndicatorView) findViewById(R.id.scaleindicator);
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/GoogleLoggerMap.java | Java | gpl3 | 12,883 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Feb 26, 2012 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*/
package nl.sogeti.android.gpstracker.viewer.map;
import java.util.concurrent.Semaphore;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.ControlTracking;
import nl.sogeti.android.gpstracker.actions.InsertNote;
import nl.sogeti.android.gpstracker.actions.ShareTrack;
import nl.sogeti.android.gpstracker.actions.Statistics;
import nl.sogeti.android.gpstracker.db.GPStracking.Media;
import nl.sogeti.android.gpstracker.db.GPStracking.Segments;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.logger.GPSLoggerServiceManager;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.SlidingIndicatorView;
import nl.sogeti.android.gpstracker.util.UnitsI18n;
import nl.sogeti.android.gpstracker.viewer.About;
import nl.sogeti.android.gpstracker.viewer.ApplicationPreferenceActivity;
import nl.sogeti.android.gpstracker.viewer.TrackList;
import nl.sogeti.android.gpstracker.viewer.map.overlay.BitmapSegmentsOverlay;
import nl.sogeti.android.gpstracker.viewer.map.overlay.SegmentRendering;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.database.ContentObserver;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.location.Location;
import android.location.LocationManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.ContextMenu;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.BaseAdapter;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.Gallery;
import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.TextView;
import com.google.android.maps.GeoPoint;
/**
* ????
*
* @version $Id:$
* @author rene (c) Feb 26, 2012, Sogeti B.V.
*/
public class LoggerMapHelper
{
public static final String OSM_PROVIDER = "OSM";
public static final String GOOGLE_PROVIDER = "GOOGLE";
public static final String MAPQUEST_PROVIDER = "MAPQUEST";
private static final String INSTANCE_E6LONG = "e6long";
private static final String INSTANCE_E6LAT = "e6lat";
private static final String INSTANCE_ZOOM = "zoom";
private static final String INSTANCE_AVGSPEED = "averagespeed";
private static final String INSTANCE_HEIGHT = "averageheight";
private static final String INSTANCE_TRACK = "track";
private static final String INSTANCE_SPEED = "speed";
private static final String INSTANCE_ALTITUDE = "altitude";
private static final String INSTANCE_DISTANCE = "distance";
private static final int ZOOM_LEVEL = 16;
// MENU'S
private static final int MENU_SETTINGS = 1;
private static final int MENU_TRACKING = 2;
private static final int MENU_TRACKLIST = 3;
private static final int MENU_STATS = 4;
private static final int MENU_ABOUT = 5;
private static final int MENU_LAYERS = 6;
private static final int MENU_NOTE = 7;
private static final int MENU_SHARE = 13;
private static final int MENU_CONTRIB = 14;
private static final int DIALOG_NOTRACK = 24;
private static final int DIALOG_LAYERS = 31;
private static final int DIALOG_URIS = 34;
private static final int DIALOG_CONTRIB = 35;
private static final String TAG = "OGT.LoggerMap";
private double mAverageSpeed = 33.33d / 3d;
private double mAverageHeight = 33.33d / 3d;
private long mTrackId = -1;
private long mLastSegment = -1;
private UnitsI18n mUnits;
private WakeLock mWakeLock = null;
private SharedPreferences mSharedPreferences;
private GPSLoggerServiceManager mLoggerServiceManager;
private SegmentRendering mLastSegmentOverlay;
private BaseAdapter mMediaAdapter;
private Handler mHandler;
private ContentObserver mTrackSegmentsObserver;
private ContentObserver mSegmentWaypointsObserver;
private ContentObserver mTrackMediasObserver;
private DialogInterface.OnClickListener mNoTrackDialogListener;
private OnItemSelectedListener mGalerySelectListener;
private Uri mSelected;
private OnClickListener mNoteSelectDialogListener;
private OnCheckedChangeListener mCheckedChangeListener;
private android.widget.RadioGroup.OnCheckedChangeListener mGroupCheckedChangeListener;
private OnSharedPreferenceChangeListener mSharedPreferenceChangeListener;
private UnitsI18n.UnitsChangeListener mUnitsChangeListener;
/**
* Run after the ServiceManager completes the binding to the remote service
*/
private Runnable mServiceConnected;
private Runnable speedCalculator;
private Runnable heightCalculator;
private LoggerMap mLoggerMap;
private BitmapSegmentsOverlay mBitmapSegmentsOverlay;
private float mSpeed;
private double mAltitude;
private float mDistance;
public LoggerMapHelper(LoggerMap loggerMap)
{
mLoggerMap = loggerMap;
}
/**
* Called when the activity is first created.
*/
protected void onCreate(Bundle load)
{
mLoggerMap.setDrawingCacheEnabled(true);
mUnits = new UnitsI18n(mLoggerMap.getActivity());
mLoggerServiceManager = new GPSLoggerServiceManager(mLoggerMap.getActivity());
final Semaphore calulatorSemaphore = new Semaphore(0);
Thread calulator = new Thread("OverlayCalculator")
{
@Override
public void run()
{
Looper.prepare();
mHandler = new Handler();
calulatorSemaphore.release();
Looper.loop();
}
};
calulator.start();
try
{
calulatorSemaphore.acquire();
}
catch (InterruptedException e)
{
Log.e(TAG, "Failed waiting for a semaphore", e);
}
mSharedPreferences = PreferenceManager.getDefaultSharedPreferences(mLoggerMap.getActivity());
mBitmapSegmentsOverlay = new BitmapSegmentsOverlay(mLoggerMap, mHandler);
createListeners();
onRestoreInstanceState(load);
mLoggerMap.updateOverlays();
}
protected void onResume()
{
updateMapProvider();
mLoggerServiceManager.startup(mLoggerMap.getActivity(), mServiceConnected);
mSharedPreferences.registerOnSharedPreferenceChangeListener(mSharedPreferenceChangeListener);
mUnits.setUnitsChangeListener(mUnitsChangeListener);
updateTitleBar();
updateBlankingBehavior();
if (mTrackId >= 0)
{
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
Uri trackUri = Uri.withAppendedPath(Tracks.CONTENT_URI, mTrackId + "/segments");
Uri lastSegmentUri = Uri.withAppendedPath(Tracks.CONTENT_URI, mTrackId + "/segments/" + mLastSegment + "/waypoints");
Uri mediaUri = ContentUris.withAppendedId(Media.CONTENT_URI, mTrackId);
resolver.unregisterContentObserver(this.mTrackSegmentsObserver);
resolver.unregisterContentObserver(this.mSegmentWaypointsObserver);
resolver.unregisterContentObserver(this.mTrackMediasObserver);
resolver.registerContentObserver(trackUri, false, this.mTrackSegmentsObserver);
resolver.registerContentObserver(lastSegmentUri, true, this.mSegmentWaypointsObserver);
resolver.registerContentObserver(mediaUri, true, this.mTrackMediasObserver);
}
updateDataOverlays();
updateSpeedColoring();
updateSpeedDisplayVisibility();
updateAltitudeDisplayVisibility();
updateDistanceDisplayVisibility();
updateCompassDisplayVisibility();
updateLocationDisplayVisibility();
updateTrackNumbers();
mLoggerMap.executePostponedActions();
}
protected void onPause()
{
if (this.mWakeLock != null && this.mWakeLock.isHeld())
{
this.mWakeLock.release();
Log.w(TAG, "onPause(): Released lock to keep screen on!");
}
mLoggerMap.clearOverlays();
mBitmapSegmentsOverlay.clearSegments();
mLastSegmentOverlay = null;
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
resolver.unregisterContentObserver(this.mTrackSegmentsObserver);
resolver.unregisterContentObserver(this.mSegmentWaypointsObserver);
resolver.unregisterContentObserver(this.mTrackMediasObserver);
mSharedPreferences.unregisterOnSharedPreferenceChangeListener(this.mSharedPreferenceChangeListener);
mUnits.setUnitsChangeListener(null);
mLoggerMap.disableMyLocation();
mLoggerMap.disableCompass();
this.mLoggerServiceManager.shutdown(mLoggerMap.getActivity());
}
protected void onDestroy()
{
mLoggerMap.clearOverlays();
mHandler.post(new Runnable()
{
@Override
public void run()
{
Looper.myLooper().quit();
}
});
if (mWakeLock != null && mWakeLock.isHeld())
{
mWakeLock.release();
Log.w(TAG, "onDestroy(): Released lock to keep screen on!");
}
if (mLoggerServiceManager.getLoggingState() == Constants.STOPPED)
{
mLoggerMap.getActivity().stopService(new Intent(Constants.SERVICENAME));
}
mUnits = null;
}
public void onNewIntent(Intent newIntent)
{
Uri data = newIntent.getData();
if (data != null)
{
moveToTrack(Long.parseLong(data.getLastPathSegment()), true);
}
}
protected void onRestoreInstanceState(Bundle load)
{
Uri data = mLoggerMap.getActivity().getIntent().getData();
if (load != null && load.containsKey(INSTANCE_TRACK)) // 1st method: track from a previous instance of this activity
{
long loadTrackId = load.getLong(INSTANCE_TRACK);
moveToTrack(loadTrackId, false);
if (load.containsKey(INSTANCE_AVGSPEED))
{
mAverageSpeed = load.getDouble(INSTANCE_AVGSPEED);
}
if (load.containsKey(INSTANCE_HEIGHT))
{
mAverageHeight = load.getDouble(INSTANCE_HEIGHT);
}
if( load.containsKey(INSTANCE_SPEED))
{
mSpeed = load.getFloat(INSTANCE_SPEED);
}
if( load.containsKey(INSTANCE_ALTITUDE))
{
mAltitude = load.getDouble(INSTANCE_HEIGHT);
}
if( load.containsKey(INSTANCE_DISTANCE))
{
mDistance = load.getFloat(INSTANCE_DISTANCE);
}
}
else if (data != null) // 2nd method: track ordered to make
{
long loadTrackId = Long.parseLong(data.getLastPathSegment());
moveToTrack(loadTrackId, true);
}
else
// 3rd method: just try the last track
{
moveToLastTrack();
}
if (load != null && load.containsKey(INSTANCE_ZOOM))
{
mLoggerMap.setZoom(load.getInt(INSTANCE_ZOOM));
}
else
{
mLoggerMap.setZoom(ZOOM_LEVEL);
}
if (load != null && load.containsKey(INSTANCE_E6LAT) && load.containsKey(INSTANCE_E6LONG))
{
GeoPoint storedPoint = new GeoPoint(load.getInt(INSTANCE_E6LAT), load.getInt(INSTANCE_E6LONG));
mLoggerMap.animateTo(storedPoint);
}
else
{
GeoPoint lastPoint = getLastTrackPoint();
mLoggerMap.animateTo(lastPoint);
}
}
protected void onSaveInstanceState(Bundle save)
{
save.putLong(INSTANCE_TRACK, this.mTrackId);
save.putDouble(INSTANCE_AVGSPEED, mAverageSpeed);
save.putDouble(INSTANCE_HEIGHT, mAverageHeight);
save.putInt(INSTANCE_ZOOM, mLoggerMap.getZoomLevel());
save.putFloat(INSTANCE_SPEED, mSpeed);
save.putDouble(INSTANCE_ALTITUDE, mAltitude);
save.putFloat(INSTANCE_DISTANCE, mDistance);
GeoPoint point = mLoggerMap.getMapCenter();
save.putInt(INSTANCE_E6LAT, point.getLatitudeE6());
save.putInt(INSTANCE_E6LONG, point.getLongitudeE6());
}
public boolean onKeyDown(int keyCode, KeyEvent event)
{
boolean propagate = true;
switch (keyCode)
{
case KeyEvent.KEYCODE_T:
propagate = mLoggerMap.zoomIn();
propagate = false;
break;
case KeyEvent.KEYCODE_G:
propagate = mLoggerMap.zoomOut();
propagate = false;
break;
case KeyEvent.KEYCODE_F:
moveToTrack(this.mTrackId - 1, true);
propagate = false;
break;
case KeyEvent.KEYCODE_H:
moveToTrack(this.mTrackId + 1, true);
propagate = false;
break;
}
return propagate;
}
private void setSpeedOverlay(boolean b)
{
Editor editor = mSharedPreferences.edit();
editor.putBoolean(Constants.SPEED, b);
editor.commit();
}
private void setAltitudeOverlay(boolean b)
{
Editor editor = mSharedPreferences.edit();
editor.putBoolean(Constants.ALTITUDE, b);
editor.commit();
}
private void setDistanceOverlay(boolean b)
{
Editor editor = mSharedPreferences.edit();
editor.putBoolean(Constants.DISTANCE, b);
editor.commit();
}
private void setCompassOverlay(boolean b)
{
Editor editor = mSharedPreferences.edit();
editor.putBoolean(Constants.COMPASS, b);
editor.commit();
}
private void setLocationOverlay(boolean b)
{
Editor editor = mSharedPreferences.edit();
editor.putBoolean(Constants.LOCATION, b);
editor.commit();
}
private void setOsmBaseOverlay(int b)
{
Editor editor = mSharedPreferences.edit();
editor.putInt(Constants.OSMBASEOVERLAY, b);
editor.commit();
}
private void createListeners()
{
/*******************************************************
* 8 Runnable listener actions
*/
speedCalculator = new Runnable()
{
@Override
public void run()
{
double avgspeed = 0.0;
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
Cursor waypointsCursor = null;
try
{
waypointsCursor = resolver.query(Uri.withAppendedPath(Tracks.CONTENT_URI, LoggerMapHelper.this.mTrackId + "/waypoints"), new String[] {
"avg(" + Waypoints.SPEED + ")", "max(" + Waypoints.SPEED + ")" }, null, null, null);
if (waypointsCursor != null && waypointsCursor.moveToLast())
{
double average = waypointsCursor.getDouble(0);
double maxBasedAverage = waypointsCursor.getDouble(1) / 2;
avgspeed = Math.min(average, maxBasedAverage);
}
if (avgspeed < 2)
{
avgspeed = 5.55d / 2;
}
}
finally
{
if (waypointsCursor != null)
{
waypointsCursor.close();
}
}
mAverageSpeed = avgspeed;
mLoggerMap.getActivity().runOnUiThread(new Runnable()
{
@Override
public void run()
{
updateSpeedColoring();
}
});
}
};
heightCalculator = new Runnable()
{
@Override
public void run()
{
double avgHeight = 0.0;
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
Cursor waypointsCursor = null;
try
{
waypointsCursor = resolver.query(Uri.withAppendedPath(Tracks.CONTENT_URI, LoggerMapHelper.this.mTrackId + "/waypoints"), new String[] {
"avg(" + Waypoints.ALTITUDE + ")", "max(" + Waypoints.ALTITUDE + ")" }, null, null, null);
if (waypointsCursor != null && waypointsCursor.moveToLast())
{
double average = waypointsCursor.getDouble(0);
double maxBasedAverage = waypointsCursor.getDouble(1) / 2;
avgHeight = Math.min(average, maxBasedAverage);
}
}
finally
{
if (waypointsCursor != null)
{
waypointsCursor.close();
}
}
mAverageHeight = avgHeight;
mLoggerMap.getActivity().runOnUiThread(new Runnable()
{
@Override
public void run()
{
updateSpeedColoring();
}
});
}
};
mServiceConnected = new Runnable()
{
@Override
public void run()
{
updateBlankingBehavior();
}
};
/*******************************************************
* 8 Various dialog listeners
*/
mGalerySelectListener = new AdapterView.OnItemSelectedListener()
{
@Override
public void onItemSelected(AdapterView< ? > parent, View view, int pos, long id)
{
mSelected = (Uri) parent.getSelectedItem();
}
@Override
public void onNothingSelected(AdapterView< ? > arg0)
{
mSelected = null;
}
};
mNoteSelectDialogListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
SegmentRendering.handleMedia(mLoggerMap.getActivity(), mSelected);
mSelected = null;
}
};
mGroupCheckedChangeListener = new android.widget.RadioGroup.OnCheckedChangeListener()
{
@Override
public void onCheckedChanged(RadioGroup group, int checkedId)
{
switch (checkedId)
{
case R.id.layer_osm_cloudmade:
setOsmBaseOverlay(Constants.OSM_CLOUDMADE);
break;
case R.id.layer_osm_maknik:
setOsmBaseOverlay(Constants.OSM_MAKNIK);
break;
case R.id.layer_osm_bicycle:
setOsmBaseOverlay(Constants.OSM_CYCLE);
break;
default:
mLoggerMap.onLayerCheckedChanged(checkedId, true);
break;
}
}
};
mCheckedChangeListener = new OnCheckedChangeListener()
{
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked)
{
int checkedId;
checkedId = buttonView.getId();
switch (checkedId)
{
case R.id.layer_speed:
setSpeedOverlay(isChecked);
break;
case R.id.layer_altitude:
setAltitudeOverlay(isChecked);
break;
case R.id.layer_distance:
setDistanceOverlay(isChecked);
break;
case R.id.layer_compass:
setCompassOverlay(isChecked);
break;
case R.id.layer_location:
setLocationOverlay(isChecked);
break;
default:
mLoggerMap.onLayerCheckedChanged(checkedId, isChecked);
break;
}
}
};
mNoTrackDialogListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
// Log.d( TAG, "mNoTrackDialogListener" + which);
Intent tracklistIntent = new Intent(mLoggerMap.getActivity(), TrackList.class);
tracklistIntent.putExtra(Tracks._ID, mTrackId);
mLoggerMap.getActivity().startActivityForResult(tracklistIntent, MENU_TRACKLIST);
}
};
/**
* Listeners to events outside this mapview
*/
mSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener()
{
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
{
if (key.equals(Constants.TRACKCOLORING))
{
mAverageSpeed = 0.0;
mAverageHeight = 0.0;
updateSpeedColoring();
}
else if (key.equals(Constants.DISABLEBLANKING) || key.equals(Constants.DISABLEDIMMING))
{
updateBlankingBehavior();
}
else if (key.equals(Constants.SPEED))
{
updateSpeedDisplayVisibility();
}
else if (key.equals(Constants.ALTITUDE))
{
updateAltitudeDisplayVisibility();
}
else if (key.equals(Constants.DISTANCE))
{
updateDistanceDisplayVisibility();
}
else if (key.equals(Constants.COMPASS))
{
updateCompassDisplayVisibility();
}
else if (key.equals(Constants.LOCATION))
{
updateLocationDisplayVisibility();
}
else if (key.equals(Constants.MAPPROVIDER))
{
updateMapProvider();
}
else if (key.equals(Constants.OSMBASEOVERLAY))
{
mLoggerMap.updateOverlays();
}
else
{
mLoggerMap.onSharedPreferenceChanged(sharedPreferences, key);
}
}
};
mTrackMediasObserver = new ContentObserver(new Handler())
{
@Override
public void onChange(boolean selfUpdate)
{
if (!selfUpdate)
{
if (mLastSegmentOverlay != null)
{
mLastSegmentOverlay.calculateMedia();
}
}
else
{
Log.w(TAG, "mTrackMediasObserver skipping change on " + mLastSegment);
}
}
};
mTrackSegmentsObserver = new ContentObserver(new Handler())
{
@Override
public void onChange(boolean selfUpdate)
{
if (!selfUpdate)
{
updateDataOverlays();
}
else
{
Log.w(TAG, "mTrackSegmentsObserver skipping change on " + mLastSegment);
}
}
};
mSegmentWaypointsObserver = new ContentObserver(new Handler())
{
@Override
public void onChange(boolean selfUpdate)
{
if (!selfUpdate)
{
updateTrackNumbers();
if (mLastSegmentOverlay != null)
{
moveActiveViewWindow();
updateMapProviderAdministration(mLoggerMap.getDataSourceId());
}
else
{
Log.e(TAG, "Error the last segment changed but it is not on screen! " + mLastSegment);
}
}
else
{
Log.w(TAG, "mSegmentWaypointsObserver skipping change on " + mLastSegment);
}
}
};
mUnitsChangeListener = new UnitsI18n.UnitsChangeListener()
{
@Override
public void onUnitsChange()
{
mAverageSpeed = 0.0;
mAverageHeight = 0.0;
updateTrackNumbers();
updateSpeedColoring();
}
};
}
public void onCreateOptionsMenu(Menu menu)
{
menu.add(ContextMenu.NONE, MENU_TRACKING, ContextMenu.NONE, R.string.menu_tracking).setIcon(R.drawable.ic_menu_movie).setAlphabeticShortcut('T');
menu.add(ContextMenu.NONE, MENU_LAYERS, ContextMenu.NONE, R.string.menu_showLayers).setIcon(R.drawable.ic_menu_mapmode).setAlphabeticShortcut('L');
menu.add(ContextMenu.NONE, MENU_NOTE, ContextMenu.NONE, R.string.menu_insertnote).setIcon(R.drawable.ic_menu_myplaces);
menu.add(ContextMenu.NONE, MENU_STATS, ContextMenu.NONE, R.string.menu_statistics).setIcon(R.drawable.ic_menu_picture).setAlphabeticShortcut('S');
menu.add(ContextMenu.NONE, MENU_SHARE, ContextMenu.NONE, R.string.menu_shareTrack).setIcon(R.drawable.ic_menu_share).setAlphabeticShortcut('I');
// More
menu.add(ContextMenu.NONE, MENU_TRACKLIST, ContextMenu.NONE, R.string.menu_tracklist).setIcon(R.drawable.ic_menu_show_list).setAlphabeticShortcut('P');
menu.add(ContextMenu.NONE, MENU_SETTINGS, ContextMenu.NONE, R.string.menu_settings).setIcon(R.drawable.ic_menu_preferences).setAlphabeticShortcut('C');
menu.add(ContextMenu.NONE, MENU_ABOUT, ContextMenu.NONE, R.string.menu_about).setIcon(R.drawable.ic_menu_info_details).setAlphabeticShortcut('A');
menu.add(ContextMenu.NONE, MENU_CONTRIB, ContextMenu.NONE, R.string.menu_contrib).setIcon(R.drawable.ic_menu_allfriends);
}
public void onPrepareOptionsMenu(Menu menu)
{
MenuItem noteMenu = menu.findItem(MENU_NOTE);
noteMenu.setEnabled(mLoggerServiceManager.isMediaPrepared());
MenuItem shareMenu = menu.findItem(MENU_SHARE);
shareMenu.setEnabled(mTrackId >= 0);
}
public boolean onOptionsItemSelected(MenuItem item)
{
boolean handled = false;
Uri trackUri;
Intent intent;
switch (item.getItemId())
{
case MENU_TRACKING:
intent = new Intent(mLoggerMap.getActivity(), ControlTracking.class);
mLoggerMap.getActivity().startActivityForResult(intent, MENU_TRACKING);
handled = true;
break;
case MENU_LAYERS:
mLoggerMap.getActivity().showDialog(DIALOG_LAYERS);
handled = true;
break;
case MENU_NOTE:
intent = new Intent(mLoggerMap.getActivity(), InsertNote.class);
mLoggerMap.getActivity().startActivityForResult(intent, MENU_NOTE);
handled = true;
break;
case MENU_SETTINGS:
intent = new Intent(mLoggerMap.getActivity(), ApplicationPreferenceActivity.class);
mLoggerMap.getActivity().startActivity(intent);
handled = true;
break;
case MENU_TRACKLIST:
intent = new Intent(mLoggerMap.getActivity(), TrackList.class);
intent.putExtra(Tracks._ID, this.mTrackId);
mLoggerMap.getActivity().startActivityForResult(intent, MENU_TRACKLIST);
handled = true;
break;
case MENU_STATS:
if (this.mTrackId >= 0)
{
intent = new Intent(mLoggerMap.getActivity(), Statistics.class);
trackUri = ContentUris.withAppendedId(Tracks.CONTENT_URI, mTrackId);
intent.setData(trackUri);
mLoggerMap.getActivity().startActivity(intent);
break;
}
else
{
mLoggerMap.getActivity().showDialog(DIALOG_NOTRACK);
}
handled = true;
break;
case MENU_ABOUT:
intent = new Intent(mLoggerMap.getActivity(), About.class);
mLoggerMap.getActivity().startActivity(intent);
break;
case MENU_SHARE:
intent = new Intent(Intent.ACTION_RUN);
trackUri = ContentUris.withAppendedId(Tracks.CONTENT_URI, mTrackId);
intent.setDataAndType(trackUri, Tracks.CONTENT_ITEM_TYPE);
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
Bitmap bm = mLoggerMap.getDrawingCache();
Uri screenStreamUri = ShareTrack.storeScreenBitmap(bm);
intent.putExtra(Intent.EXTRA_STREAM, screenStreamUri);
mLoggerMap.getActivity().startActivityForResult(Intent.createChooser(intent, mLoggerMap.getActivity().getString(R.string.share_track)), MENU_SHARE);
handled = true;
break;
case MENU_CONTRIB:
mLoggerMap.getActivity().showDialog(DIALOG_CONTRIB);
default:
handled = false;
break;
}
return handled;
}
protected Dialog onCreateDialog(int id)
{
Dialog dialog = null;
LayoutInflater factory = null;
View view = null;
Builder builder = null;
switch (id)
{
case DIALOG_LAYERS:
builder = new AlertDialog.Builder(mLoggerMap.getActivity());
factory = LayoutInflater.from(mLoggerMap.getActivity());
view = factory.inflate(R.layout.layerdialog, null);
CheckBox traffic = (CheckBox) view.findViewById(R.id.layer_traffic);
CheckBox speed = (CheckBox) view.findViewById(R.id.layer_speed);
CheckBox altitude = (CheckBox) view.findViewById(R.id.layer_altitude);
CheckBox distance = (CheckBox) view.findViewById(R.id.layer_distance);
CheckBox compass = (CheckBox) view.findViewById(R.id.layer_compass);
CheckBox location = (CheckBox) view.findViewById(R.id.layer_location);
((RadioGroup) view.findViewById(R.id.google_backgrounds)).setOnCheckedChangeListener(mGroupCheckedChangeListener);
((RadioGroup) view.findViewById(R.id.osm_backgrounds)).setOnCheckedChangeListener(mGroupCheckedChangeListener);
traffic.setOnCheckedChangeListener(mCheckedChangeListener);
speed.setOnCheckedChangeListener(mCheckedChangeListener);
altitude.setOnCheckedChangeListener(mCheckedChangeListener);
distance.setOnCheckedChangeListener(mCheckedChangeListener);
compass.setOnCheckedChangeListener(mCheckedChangeListener);
location.setOnCheckedChangeListener(mCheckedChangeListener);
builder.setTitle(R.string.dialog_layer_title).setIcon(android.R.drawable.ic_dialog_map).setPositiveButton(R.string.btn_okay, null).setView(view);
dialog = builder.create();
return dialog;
case DIALOG_NOTRACK:
builder = new AlertDialog.Builder(mLoggerMap.getActivity());
builder.setTitle(R.string.dialog_notrack_title).setMessage(R.string.dialog_notrack_message).setIcon(android.R.drawable.ic_dialog_alert)
.setPositiveButton(R.string.btn_selecttrack, mNoTrackDialogListener).setNegativeButton(R.string.btn_cancel, null);
dialog = builder.create();
return dialog;
case DIALOG_URIS:
builder = new AlertDialog.Builder(mLoggerMap.getActivity());
factory = LayoutInflater.from(mLoggerMap.getActivity());
view = factory.inflate(R.layout.mediachooser, null);
builder.setTitle(R.string.dialog_select_media_title).setMessage(R.string.dialog_select_media_message).setIcon(android.R.drawable.ic_dialog_alert)
.setNegativeButton(R.string.btn_cancel, null).setPositiveButton(R.string.btn_okay, mNoteSelectDialogListener).setView(view);
dialog = builder.create();
return dialog;
case DIALOG_CONTRIB:
builder = new AlertDialog.Builder(mLoggerMap.getActivity());
factory = LayoutInflater.from(mLoggerMap.getActivity());
view = factory.inflate(R.layout.contrib, null);
TextView contribView = (TextView) view.findViewById(R.id.contrib_view);
contribView.setText(R.string.dialog_contrib_message);
builder.setTitle(R.string.dialog_contrib_title).setView(view).setIcon(android.R.drawable.ic_dialog_email)
.setPositiveButton(R.string.btn_okay, null);
dialog = builder.create();
return dialog;
default:
return null;
}
}
protected void onPrepareDialog(int id, Dialog dialog)
{
RadioButton satellite;
RadioButton regular;
RadioButton cloudmade;
RadioButton mapnik;
RadioButton cycle;
switch (id)
{
case DIALOG_LAYERS:
satellite = (RadioButton) dialog.findViewById(R.id.layer_google_satellite);
regular = (RadioButton) dialog.findViewById(R.id.layer_google_regular);
satellite.setChecked(mSharedPreferences.getBoolean(Constants.SATELLITE, false));
regular.setChecked(!mSharedPreferences.getBoolean(Constants.SATELLITE, false));
int osmbase = mSharedPreferences.getInt(Constants.OSMBASEOVERLAY, 0);
cloudmade = (RadioButton) dialog.findViewById(R.id.layer_osm_cloudmade);
mapnik = (RadioButton) dialog.findViewById(R.id.layer_osm_maknik);
cycle = (RadioButton) dialog.findViewById(R.id.layer_osm_bicycle);
cloudmade.setChecked(osmbase == Constants.OSM_CLOUDMADE);
mapnik.setChecked(osmbase == Constants.OSM_MAKNIK);
cycle.setChecked(osmbase == Constants.OSM_CYCLE);
((CheckBox) dialog.findViewById(R.id.layer_traffic)).setChecked(mSharedPreferences.getBoolean(Constants.TRAFFIC, false));
((CheckBox) dialog.findViewById(R.id.layer_speed)).setChecked(mSharedPreferences.getBoolean(Constants.SPEED, false));
((CheckBox) dialog.findViewById(R.id.layer_altitude)).setChecked(mSharedPreferences.getBoolean(Constants.ALTITUDE, false));
((CheckBox) dialog.findViewById(R.id.layer_distance)).setChecked(mSharedPreferences.getBoolean(Constants.DISTANCE, false));
((CheckBox) dialog.findViewById(R.id.layer_compass)).setChecked(mSharedPreferences.getBoolean(Constants.COMPASS, false));
((CheckBox) dialog.findViewById(R.id.layer_location)).setChecked(mSharedPreferences.getBoolean(Constants.LOCATION, false));
int provider = Integer.valueOf(mSharedPreferences.getString(Constants.MAPPROVIDER, "" + Constants.GOOGLE)).intValue();
switch (provider)
{
case Constants.GOOGLE:
dialog.findViewById(R.id.google_backgrounds).setVisibility(View.VISIBLE);
dialog.findViewById(R.id.osm_backgrounds).setVisibility(View.GONE);
dialog.findViewById(R.id.shared_layers).setVisibility(View.VISIBLE);
dialog.findViewById(R.id.google_overlays).setVisibility(View.VISIBLE);
break;
case Constants.OSM:
dialog.findViewById(R.id.osm_backgrounds).setVisibility(View.VISIBLE);
dialog.findViewById(R.id.google_backgrounds).setVisibility(View.GONE);
dialog.findViewById(R.id.shared_layers).setVisibility(View.VISIBLE);
dialog.findViewById(R.id.google_overlays).setVisibility(View.GONE);
break;
default:
dialog.findViewById(R.id.osm_backgrounds).setVisibility(View.GONE);
dialog.findViewById(R.id.google_backgrounds).setVisibility(View.GONE);
dialog.findViewById(R.id.shared_layers).setVisibility(View.VISIBLE);
dialog.findViewById(R.id.google_overlays).setVisibility(View.GONE);
break;
}
break;
case DIALOG_URIS:
Gallery gallery = (Gallery) dialog.findViewById(R.id.gallery);
gallery.setAdapter(mMediaAdapter);
gallery.setOnItemSelectedListener(mGalerySelectListener);
default:
break;
}
}
protected void onActivityResult(int requestCode, int resultCode, Intent intent)
{
Uri trackUri;
long trackId;
switch (requestCode)
{
case MENU_TRACKLIST:
if (resultCode == Activity.RESULT_OK)
{
trackUri = intent.getData();
trackId = Long.parseLong(trackUri.getLastPathSegment());
moveToTrack(trackId, true);
}
break;
case MENU_TRACKING:
if (resultCode == Activity.RESULT_OK)
{
trackUri = intent.getData();
if (trackUri != null)
{
trackId = Long.parseLong(trackUri.getLastPathSegment());
moveToTrack(trackId, true);
}
}
break;
case MENU_SHARE:
ShareTrack.clearScreenBitmap();
break;
default:
Log.e(TAG, "Returned form unknow activity: " + requestCode);
break;
}
}
private void updateTitleBar()
{
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
Cursor trackCursor = null;
try
{
trackCursor = resolver.query(ContentUris.withAppendedId(Tracks.CONTENT_URI, this.mTrackId), new String[] { Tracks.NAME }, null, null, null);
if (trackCursor != null && trackCursor.moveToLast())
{
String trackName = trackCursor.getString(0);
mLoggerMap.getActivity().setTitle(mLoggerMap.getActivity().getString(R.string.app_name) + ": " + trackName);
}
}
finally
{
if (trackCursor != null)
{
trackCursor.close();
}
}
}
private void updateMapProvider()
{
Class< ? > mapClass = null;
int provider = Integer.valueOf(mSharedPreferences.getString(Constants.MAPPROVIDER, "" + Constants.GOOGLE)).intValue();
switch (provider)
{
case Constants.GOOGLE:
mapClass = GoogleLoggerMap.class;
break;
case Constants.OSM:
mapClass = OsmLoggerMap.class;
break;
case Constants.MAPQUEST:
mapClass = MapQuestLoggerMap.class;
break;
default:
mapClass = GoogleLoggerMap.class;
Log.e(TAG, "Fault in value " + provider + " as MapProvider, defaulting to Google Maps.");
break;
}
if (mapClass != mLoggerMap.getActivity().getClass())
{
Intent myIntent = mLoggerMap.getActivity().getIntent();
Intent realIntent;
if (myIntent != null)
{
realIntent = new Intent(myIntent.getAction(), myIntent.getData(), mLoggerMap.getActivity(), mapClass);
realIntent.putExtras(myIntent);
}
else
{
realIntent = new Intent(mLoggerMap.getActivity(), mapClass);
realIntent.putExtras(myIntent);
}
mLoggerMap.getActivity().startActivity(realIntent);
mLoggerMap.getActivity().finish();
}
}
protected void updateMapProviderAdministration(String provider)
{
mLoggerServiceManager.storeDerivedDataSource(provider);
}
private void updateBlankingBehavior()
{
boolean disableblanking = mSharedPreferences.getBoolean(Constants.DISABLEBLANKING, false);
boolean disabledimming = mSharedPreferences.getBoolean(Constants.DISABLEDIMMING, false);
if (disableblanking)
{
if (mWakeLock == null)
{
PowerManager pm = (PowerManager) mLoggerMap.getActivity().getSystemService(Context.POWER_SERVICE);
if (disabledimming)
{
mWakeLock = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, TAG);
}
else
{
mWakeLock = pm.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK, TAG);
}
}
if (mLoggerServiceManager.getLoggingState() == Constants.LOGGING && !mWakeLock.isHeld())
{
mWakeLock.acquire();
Log.w(TAG, "Acquired lock to keep screen on!");
}
}
}
private void updateSpeedColoring()
{
int trackColoringMethod = Integer.valueOf(mSharedPreferences.getString(Constants.TRACKCOLORING, "3")).intValue();
View speedbar = mLoggerMap.getActivity().findViewById(R.id.speedbar);
SlidingIndicatorView scaleIndicator = mLoggerMap.getScaleIndicatorView();
TextView[] speedtexts = mLoggerMap.getSpeedTextViews();
switch (trackColoringMethod)
{
case SegmentRendering.DRAW_MEASURED:
case SegmentRendering.DRAW_CALCULATED:
// mAverageSpeed is set to 0 if unknown or to trigger an recalculation here
if (mAverageSpeed == 0.0)
{
mHandler.removeCallbacks(speedCalculator);
mHandler.post(speedCalculator);
}
else
{
drawSpeedTexts();
speedtexts = mLoggerMap.getSpeedTextViews();
speedbar.setVisibility(View.VISIBLE);
scaleIndicator.setVisibility(View.VISIBLE);
for (int i = 0; i < speedtexts.length; i++)
{
speedtexts[i].setVisibility(View.VISIBLE);
}
}
break;
case SegmentRendering.DRAW_DOTS:
case SegmentRendering.DRAW_GREEN:
case SegmentRendering.DRAW_RED:
speedbar.setVisibility(View.INVISIBLE);
scaleIndicator.setVisibility(View.INVISIBLE);
for (int i = 0; i < speedtexts.length; i++)
{
speedtexts[i].setVisibility(View.INVISIBLE);
}
break;
case SegmentRendering.DRAW_HEIGHT:
if (mAverageHeight == 0.0)
{
mHandler.removeCallbacks(heightCalculator);
mHandler.post(heightCalculator);
}
else
{
drawHeightTexts();
speedtexts = mLoggerMap.getSpeedTextViews();
speedbar.setVisibility(View.VISIBLE);
scaleIndicator.setVisibility(View.VISIBLE);
for (int i = 0; i < speedtexts.length; i++)
{
speedtexts[i].setVisibility(View.VISIBLE);
}
}
break;
default:
break;
}
mBitmapSegmentsOverlay.setTrackColoringMethod(trackColoringMethod, mAverageSpeed, mAverageHeight);
}
private void updateSpeedDisplayVisibility()
{
boolean showspeed = mSharedPreferences.getBoolean(Constants.SPEED, false);
TextView lastGPSSpeedView = mLoggerMap.getSpeedTextView();
if (showspeed)
{
lastGPSSpeedView.setVisibility(View.VISIBLE);
}
else
{
lastGPSSpeedView.setVisibility(View.GONE);
}
updateScaleDisplayVisibility();
}
private void updateAltitudeDisplayVisibility()
{
boolean showaltitude = mSharedPreferences.getBoolean(Constants.ALTITUDE, false);
TextView lastGPSAltitudeView = mLoggerMap.getAltitideTextView();
if (showaltitude)
{
lastGPSAltitudeView.setVisibility(View.VISIBLE);
}
else
{
lastGPSAltitudeView.setVisibility(View.GONE);
}
updateScaleDisplayVisibility();
}
private void updateScaleDisplayVisibility()
{
SlidingIndicatorView scaleIndicator = mLoggerMap.getScaleIndicatorView();
boolean showspeed = mSharedPreferences.getBoolean(Constants.SPEED, false);
boolean showaltitude = mSharedPreferences.getBoolean(Constants.ALTITUDE, false);
int trackColoringMethod = Integer.valueOf(mSharedPreferences.getString(Constants.TRACKCOLORING, "3")).intValue();
switch (trackColoringMethod)
{
case SegmentRendering.DRAW_MEASURED:
case SegmentRendering.DRAW_CALCULATED:
if( showspeed )
{
scaleIndicator.setVisibility(View.VISIBLE);
}
else
{
scaleIndicator.setVisibility(View.GONE);
}
break;
case SegmentRendering.DRAW_HEIGHT:
default:
if( showaltitude )
{
scaleIndicator.setVisibility(View.VISIBLE);
}
else
{
scaleIndicator.setVisibility(View.GONE);
}
break;
}
}
private void updateDistanceDisplayVisibility()
{
boolean showdistance = mSharedPreferences.getBoolean(Constants.DISTANCE, false);
TextView distanceView = mLoggerMap.getDistanceTextView();
if (showdistance)
{
distanceView.setVisibility(View.VISIBLE);
}
else
{
distanceView.setVisibility(View.GONE);
}
}
private void updateCompassDisplayVisibility()
{
boolean compass = mSharedPreferences.getBoolean(Constants.COMPASS, false);
if (compass)
{
mLoggerMap.enableCompass();
}
else
{
mLoggerMap.disableCompass();
}
}
private void updateLocationDisplayVisibility()
{
boolean location = mSharedPreferences.getBoolean(Constants.LOCATION, false);
if (location)
{
mLoggerMap.enableMyLocation();
}
else
{
mLoggerMap.disableMyLocation();
}
}
/**
* Retrieves the numbers of the measured speed and altitude from the most
* recent waypoint and updates UI components with this latest bit of
* information.
*/
private void updateTrackNumbers()
{
Location lastWaypoint = mLoggerServiceManager.getLastWaypoint();
UnitsI18n units = mUnits;
if (lastWaypoint != null && units != null)
{
// Speed number
mSpeed = lastWaypoint.getSpeed();
mAltitude = lastWaypoint.getAltitude();
mDistance = mLoggerServiceManager.getTrackedDistance();
}
//Distance number
double distance = units.conversionFromMeter(mDistance);
String distanceText = String.format("%.2f %s", distance, units.getDistanceUnit());
TextView mDistanceView = mLoggerMap.getDistanceTextView();
mDistanceView.setText(distanceText);
//Speed number
double speed = units.conversionFromMetersPerSecond(mSpeed);
String speedText = units.formatSpeed(speed, false);
TextView lastGPSSpeedView = mLoggerMap.getSpeedTextView();
lastGPSSpeedView.setText(speedText);
//Altitude number
double altitude = units.conversionFromMeterToHeight(mAltitude);
String altitudeText = String.format("%.0f %s", altitude, units.getHeightUnit());
TextView mLastGPSAltitudeView = mLoggerMap.getAltitideTextView();
mLastGPSAltitudeView.setText(altitudeText);
// Slider indicator
SlidingIndicatorView currentScaleIndicator = mLoggerMap.getScaleIndicatorView();
int trackColoringMethod = Integer.valueOf(mSharedPreferences.getString(Constants.TRACKCOLORING, "3")).intValue();
if( trackColoringMethod == SegmentRendering.DRAW_MEASURED || trackColoringMethod == SegmentRendering.DRAW_CALCULATED)
{
currentScaleIndicator.setValue((float) speed);
// Speed color bar and reference numbers
if (speed > 2 * mAverageSpeed )
{
mAverageSpeed = 0.0;
updateSpeedColoring();
mBitmapSegmentsOverlay.scheduleRecalculation();
}
}
else if(trackColoringMethod == SegmentRendering.DRAW_HEIGHT)
{
currentScaleIndicator.setValue((float) altitude);
// Speed color bar and reference numbers
if (altitude > 2 * mAverageHeight )
{
mAverageHeight = 0.0;
updateSpeedColoring();
mLoggerMap.postInvalidate();
}
}
}
/**
* For the current track identifier the route of that track is drawn by
* adding a OverLay for each segments in the track
*
* @param trackId
* @see SegmentRendering
*/
private void createDataOverlays()
{
mLastSegmentOverlay = null;
mBitmapSegmentsOverlay.clearSegments();
mLoggerMap.clearOverlays();
mLoggerMap.addOverlay(mBitmapSegmentsOverlay);
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
Cursor segments = null;
int trackColoringMethod = Integer.valueOf(mSharedPreferences.getString(Constants.TRACKCOLORING, "2")).intValue();
try
{
Uri segmentsUri = Uri.withAppendedPath(Tracks.CONTENT_URI, this.mTrackId + "/segments");
segments = resolver.query(segmentsUri, new String[] { Segments._ID }, null, null, null);
if (segments != null && segments.moveToFirst())
{
do
{
long segmentsId = segments.getLong(0);
Uri segmentUri = ContentUris.withAppendedId(segmentsUri, segmentsId);
SegmentRendering segmentOverlay = new SegmentRendering(mLoggerMap, segmentUri, trackColoringMethod, mAverageSpeed, mAverageHeight, mHandler);
mBitmapSegmentsOverlay.addSegment(segmentOverlay);
mLastSegmentOverlay = segmentOverlay;
if (segments.isFirst())
{
segmentOverlay.addPlacement(SegmentRendering.FIRST_SEGMENT);
}
if (segments.isLast())
{
segmentOverlay.addPlacement(SegmentRendering.LAST_SEGMENT);
}
mLastSegment = segmentsId;
}
while (segments.moveToNext());
}
}
finally
{
if (segments != null)
{
segments.close();
}
}
Uri lastSegmentUri = Uri.withAppendedPath(Tracks.CONTENT_URI, mTrackId + "/segments/" + mLastSegment + "/waypoints");
resolver.unregisterContentObserver(this.mSegmentWaypointsObserver);
resolver.registerContentObserver(lastSegmentUri, false, this.mSegmentWaypointsObserver);
}
private void updateDataOverlays()
{
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
Uri segmentsUri = Uri.withAppendedPath(Tracks.CONTENT_URI, this.mTrackId + "/segments");
Cursor segmentsCursor = null;
int segmentOverlaysCount = mBitmapSegmentsOverlay.size();
try
{
segmentsCursor = resolver.query(segmentsUri, new String[] { Segments._ID }, null, null, null);
if (segmentsCursor != null && segmentsCursor.getCount() == segmentOverlaysCount)
{
// Log.d( TAG, "Alignment of segments" );
}
else
{
createDataOverlays();
}
}
finally
{
if (segmentsCursor != null)
{
segmentsCursor.close();
}
}
}
/**
* Call when an overlay has recalulated and has new information to be redrawn
*/
private void moveActiveViewWindow()
{
GeoPoint lastPoint = getLastTrackPoint();
if (lastPoint != null && mLoggerServiceManager.getLoggingState() == Constants.LOGGING)
{
if (mLoggerMap.isOutsideScreen(lastPoint))
{
mLoggerMap.clearAnimation();
mLoggerMap.setCenter(lastPoint);
}
else if (mLoggerMap.isNearScreenEdge(lastPoint))
{
mLoggerMap.clearAnimation();
mLoggerMap.animateTo(lastPoint);
}
}
}
/**
* Updates the labels next to the color bar with speeds
*/
private void drawSpeedTexts()
{
UnitsI18n units = mUnits;
if (units != null)
{
double avgSpeed = units.conversionFromMetersPerSecond(mAverageSpeed);
TextView[] mSpeedtexts = mLoggerMap.getSpeedTextViews();
SlidingIndicatorView currentScaleIndicator = mLoggerMap.getScaleIndicatorView();
for (int i = 0; i < mSpeedtexts.length; i++)
{
mSpeedtexts[i].setVisibility(View.VISIBLE);
double speed;
if (mUnits.isUnitFlipped())
{
speed = ((avgSpeed * 2d) / 5d) * (mSpeedtexts.length - i - 1);
}
else
{
speed = ((avgSpeed * 2d) / 5d) * i;
}
if( i == 0 )
{
currentScaleIndicator.setMin((float) speed);
}
else
{
currentScaleIndicator.setMax((float) speed);
}
String speedText = units.formatSpeed(speed, false);
mSpeedtexts[i].setText(speedText);
}
}
}
/**
* Updates the labels next to the color bar with heights
*/
private void drawHeightTexts()
{
UnitsI18n units = mUnits;
if (units != null)
{
double avgHeight = units.conversionFromMeterToHeight(mAverageHeight);
TextView[] mSpeedtexts = mLoggerMap.getSpeedTextViews();
SlidingIndicatorView currentScaleIndicator = mLoggerMap.getScaleIndicatorView();
for (int i = 0; i < mSpeedtexts.length; i++)
{
mSpeedtexts[i].setVisibility(View.VISIBLE);
double height = ((avgHeight * 2d) / 5d) * i;
String heightText = String.format( "%d %s", (int)height, units.getHeightUnit() );
mSpeedtexts[i].setText(heightText);
if( i == 0 )
{
currentScaleIndicator.setMin((float) height);
}
else
{
currentScaleIndicator.setMax((float) height);
}
}
}
}
/**
* Alter this to set a new track as current.
*
* @param trackId
* @param center center on the end of the track
*/
private void moveToTrack(long trackId, boolean center)
{
if( trackId == mTrackId )
{
return;
}
Cursor track = null;
try
{
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
Uri trackUri = ContentUris.withAppendedId(Tracks.CONTENT_URI, trackId);
track = resolver.query(trackUri, new String[] { Tracks.NAME }, null, null, null);
if (track != null && track.moveToFirst())
{
this.mTrackId = trackId;
mLastSegment = -1;
resolver.unregisterContentObserver(this.mTrackSegmentsObserver);
resolver.unregisterContentObserver(this.mTrackMediasObserver);
Uri tracksegmentsUri = Uri.withAppendedPath(Tracks.CONTENT_URI, trackId + "/segments");
resolver.registerContentObserver(tracksegmentsUri, false, this.mTrackSegmentsObserver);
resolver.registerContentObserver(Media.CONTENT_URI, true, this.mTrackMediasObserver);
mLoggerMap.clearOverlays();
mBitmapSegmentsOverlay.clearSegments();
mAverageSpeed = 0.0;
mAverageHeight = 0.0;
updateTitleBar();
updateDataOverlays();
updateSpeedColoring();
if (center)
{
GeoPoint lastPoint = getLastTrackPoint();
mLoggerMap.animateTo(lastPoint);
}
}
}
finally
{
if (track != null)
{
track.close();
}
}
}
/**
* Get the last know position from the GPS provider and return that
* information wrapped in a GeoPoint to which the Map can navigate.
*
* @see GeoPoint
* @return
*/
private GeoPoint getLastKnowGeopointLocation()
{
int microLatitude = 0;
int microLongitude = 0;
LocationManager locationManager = (LocationManager) mLoggerMap.getActivity().getApplication().getSystemService(Context.LOCATION_SERVICE);
Location locationFine = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
if (locationFine != null)
{
microLatitude = (int) (locationFine.getLatitude() * 1E6d);
microLongitude = (int) (locationFine.getLongitude() * 1E6d);
}
if (locationFine == null || microLatitude == 0 || microLongitude == 0)
{
Location locationCoarse = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
if (locationCoarse != null)
{
microLatitude = (int) (locationCoarse.getLatitude() * 1E6d);
microLongitude = (int) (locationCoarse.getLongitude() * 1E6d);
}
if (locationCoarse == null || microLatitude == 0 || microLongitude == 0)
{
microLatitude = 51985105;
microLongitude = 5106132;
}
}
GeoPoint geoPoint = new GeoPoint(microLatitude, microLongitude);
return geoPoint;
}
/**
* Retrieve the last point of the current track
*
* @param context
*/
private GeoPoint getLastTrackPoint()
{
Cursor waypoint = null;
GeoPoint lastPoint = null;
// First try the service which might have a cached version
Location lastLoc = mLoggerServiceManager.getLastWaypoint();
if (lastLoc != null)
{
int microLatitude = (int) (lastLoc.getLatitude() * 1E6d);
int microLongitude = (int) (lastLoc.getLongitude() * 1E6d);
lastPoint = new GeoPoint(microLatitude, microLongitude);
}
// If nothing yet, try the content resolver and query the track
if (lastPoint == null || lastPoint.getLatitudeE6() == 0 || lastPoint.getLongitudeE6() == 0)
{
try
{
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
waypoint = resolver.query(Uri.withAppendedPath(Tracks.CONTENT_URI, mTrackId + "/waypoints"), new String[] { Waypoints.LATITUDE,
Waypoints.LONGITUDE, "max(" + Waypoints.TABLE + "." + Waypoints._ID + ")" }, null, null, null);
if (waypoint != null && waypoint.moveToLast())
{
int microLatitude = (int) (waypoint.getDouble(0) * 1E6d);
int microLongitude = (int) (waypoint.getDouble(1) * 1E6d);
lastPoint = new GeoPoint(microLatitude, microLongitude);
}
}
finally
{
if (waypoint != null)
{
waypoint.close();
}
}
}
// If nothing yet, try the last generally known location
if (lastPoint == null || lastPoint.getLatitudeE6() == 0 || lastPoint.getLongitudeE6() == 0)
{
lastPoint = getLastKnowGeopointLocation();
}
return lastPoint;
}
private void moveToLastTrack()
{
int trackId = -1;
Cursor track = null;
try
{
ContentResolver resolver = mLoggerMap.getActivity().getContentResolver();
track = resolver.query(Tracks.CONTENT_URI, new String[] { "max(" + Tracks._ID + ")", Tracks.NAME, }, null, null, null);
if (track != null && track.moveToLast())
{
trackId = track.getInt(0);
moveToTrack(trackId, false);
}
}
finally
{
if (track != null)
{
track.close();
}
}
}
/**
* Enables a SegmentOverlay to call back to the MapActivity to show a dialog
* with choices of media
*
* @param mediaAdapter
*/
public void showMediaDialog(BaseAdapter mediaAdapter)
{
mMediaAdapter = mediaAdapter;
mLoggerMap.getActivity().showDialog(DIALOG_URIS);
}
public SharedPreferences getPreferences()
{
return mSharedPreferences;
}
public boolean isLogging()
{
return mLoggerServiceManager.getLoggingState() == Constants.LOGGING;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/LoggerMapHelper.java | Java | gpl3 | 60,903 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Feb 26, 2012 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*/
package nl.sogeti.android.gpstracker.viewer.map;
import nl.sogeti.android.gpstracker.util.Constants;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.util.Log;
/**
* ????
*
* @version $Id:$
* @author rene (c) Feb 26, 2012, Sogeti B.V.
*/
public class CommonLoggerMap extends Activity
{
private static final String TAG = "OGT.CommonLoggerMap";
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
Intent myIntent = getIntent();
Intent realIntent;
Class<?> mapClass = GoogleLoggerMap.class;
int provider = Integer.valueOf(PreferenceManager.getDefaultSharedPreferences(this).getString(Constants.MAPPROVIDER, "" + Constants.GOOGLE)).intValue();
switch (provider)
{
case Constants.GOOGLE:
mapClass = GoogleLoggerMap.class;
break;
case Constants.OSM:
mapClass = OsmLoggerMap.class;
break;
case Constants.MAPQUEST:
mapClass = MapQuestLoggerMap.class;
break;
default:
mapClass = GoogleLoggerMap.class;
Log.e(TAG, "Fault in value " + provider + " as MapProvider, defaulting to Google Maps.");
break;
}
if( myIntent != null )
{
realIntent = new Intent(myIntent.getAction(), myIntent.getData(), this, mapClass);
realIntent.putExtras(myIntent);
}
else
{
realIntent = new Intent(this, mapClass);
realIntent.putExtras(myIntent);
}
startActivity(realIntent);
finish();
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/CommonLoggerMap.java | Java | gpl3 | 2,490 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Feb 26, 2012 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*/
package nl.sogeti.android.gpstracker.viewer.map;
import nl.sogeti.android.gpstracker.util.SlidingIndicatorView;
import nl.sogeti.android.gpstracker.viewer.map.overlay.OverlayProvider;
import android.app.Activity;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.graphics.Point;
import android.widget.BaseAdapter;
import android.widget.TextView;
import com.google.android.maps.GeoPoint;
/**
* ????
*
* @version $Id$
* @author rene (c) Feb 26, 2012, Sogeti B.V.
*/
public interface LoggerMap
{
void setDrawingCacheEnabled(boolean b);
Activity getActivity();
void updateOverlays();
void onLayerCheckedChanged(int checkedId, boolean b);
void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key);
Bitmap getDrawingCache();
void showMediaDialog(BaseAdapter mediaAdapter);
String getDataSourceId();
boolean isOutsideScreen(GeoPoint lastPoint);
boolean isNearScreenEdge(GeoPoint lastPoint);
void executePostponedActions();
void disableMyLocation();
void disableCompass();
void setZoom(int int1);
void animateTo(GeoPoint storedPoint);
int getZoomLevel();
GeoPoint getMapCenter();
boolean zoomOut();
boolean zoomIn();
void postInvalidate();
void enableCompass();
void enableMyLocation();
void addOverlay(OverlayProvider overlay);
void clearAnimation();
void setCenter(GeoPoint lastPoint);
int getMaxZoomLevel();
GeoPoint fromPixels(int x, int y);
boolean hasProjection();
float metersToEquatorPixels(float float1);
void toPixels(GeoPoint geopoint, Point screenPoint);
TextView[] getSpeedTextViews();
TextView getAltitideTextView();
TextView getSpeedTextView();
TextView getDistanceTextView();
void clearOverlays();
SlidingIndicatorView getScaleIndicatorView();
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/LoggerMap.java | Java | gpl3 | 2,656 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Mar 3, 2012 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*/
package nl.sogeti.android.gpstracker.viewer.map;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.util.SlidingIndicatorView;
import nl.sogeti.android.gpstracker.viewer.map.overlay.OverlayProvider;
import android.app.Activity;
import android.app.Dialog;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.graphics.Point;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.BaseAdapter;
import android.widget.TextView;
import com.google.android.maps.GeoPoint;
import com.mapquest.android.maps.MapActivity;
import com.mapquest.android.maps.MapView;
import com.mapquest.android.maps.MyLocationOverlay;
/**
* ????
*
* @version $Id:$
* @author rene (c) Mar 3, 2012, Sogeti B.V.
*/
public class MapQuestLoggerMap extends MapActivity implements LoggerMap
{
LoggerMapHelper mHelper;
private MapView mMapView;
private TextView[] mSpeedtexts;
private TextView mLastGPSSpeedView;
private TextView mLastGPSAltitudeView;
private TextView mDistanceView;
private MyLocationOverlay mMylocation;
/**
* Called when the activity is first created.
*/
@Override
protected void onCreate(Bundle load)
{
super.onCreate(load);
setContentView(R.layout.map_mapquest);
mMapView = (MapView) findViewById(R.id.myMapView);
mHelper = new LoggerMapHelper(this);
mMapView = (MapView) findViewById(R.id.myMapView);
mMylocation = new MyLocationOverlay(this, mMapView);
mMapView.setBuiltInZoomControls(true);
TextView[] speeds = { (TextView) findViewById(R.id.speedview05), (TextView) findViewById(R.id.speedview04), (TextView) findViewById(R.id.speedview03),
(TextView) findViewById(R.id.speedview02), (TextView) findViewById(R.id.speedview01), (TextView) findViewById(R.id.speedview00) };
mSpeedtexts = speeds;
mLastGPSSpeedView = (TextView) findViewById(R.id.currentSpeed);
mLastGPSAltitudeView = (TextView) findViewById(R.id.currentAltitude);
mDistanceView = (TextView) findViewById(R.id.currentDistance);
mHelper.onCreate(load);
}
@Override
protected void onResume()
{
super.onResume();
mHelper.onResume();
}
@Override
protected void onPause()
{
mHelper.onPause();
super.onPause();
}
@Override
protected void onDestroy()
{
mHelper.onDestroy();
super.onDestroy();
}
@Override
public void onNewIntent(Intent newIntent)
{
mHelper.onNewIntent(newIntent);
}
@Override
protected void onRestoreInstanceState(Bundle load)
{
if (load != null)
{
super.onRestoreInstanceState(load);
}
mHelper.onRestoreInstanceState(load);
}
@Override
protected void onSaveInstanceState(Bundle save)
{
super.onSaveInstanceState(save);
mHelper.onSaveInstanceState(save);
}
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
boolean result = super.onCreateOptionsMenu(menu);
mHelper.onCreateOptionsMenu(menu);
return result;
}
@Override
public boolean onPrepareOptionsMenu(Menu menu)
{
mHelper.onPrepareOptionsMenu(menu);
return super.onPrepareOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item)
{
boolean handled = mHelper.onOptionsItemSelected(item);
if( !handled )
{
handled = super.onOptionsItemSelected(item);
}
return handled;
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent intent)
{
super.onActivityResult(requestCode, resultCode, intent);
mHelper.onActivityResult(requestCode, resultCode, intent);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event)
{
boolean propagate = true;
switch (keyCode)
{
default:
propagate = mHelper.onKeyDown(keyCode, event);
if( propagate )
{
propagate = super.onKeyDown(keyCode, event);
}
break;
}
return propagate;
}
@Override
protected Dialog onCreateDialog(int id)
{
Dialog dialog = mHelper.onCreateDialog(id);
if( dialog == null )
{
dialog = super.onCreateDialog(id);
}
return dialog;
}
@Override
protected void onPrepareDialog(int id, Dialog dialog)
{
mHelper.onPrepareDialog(id, dialog);
super.onPrepareDialog(id, dialog);
}
/******************************/
/** Loggermap methods **/
/******************************/
@Override
public void updateOverlays()
{
}
@Override
public void setDrawingCacheEnabled(boolean b)
{
findViewById(R.id.mapScreen).setDrawingCacheEnabled(true);
}
@Override
public Activity getActivity()
{
return this;
}
@Override
public void onLayerCheckedChanged(int checkedId, boolean isChecked)
{
}
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
{
}
@Override
public Bitmap getDrawingCache()
{
return findViewById(R.id.mapScreen).getDrawingCache();
}
@Override
public void showMediaDialog(BaseAdapter mediaAdapter)
{
mHelper.showMediaDialog(mediaAdapter);
}
public void onDateOverlayChanged()
{
mMapView.postInvalidate();
}
@Override
public String getDataSourceId()
{
return LoggerMapHelper.MAPQUEST_PROVIDER;
}
@Override
public boolean isOutsideScreen(GeoPoint lastPoint)
{
Point out = new Point();
this.mMapView.getProjection().toPixels(MapQuestLoggerMap.convertGeoPoint(lastPoint), out);
int height = this.mMapView.getHeight();
int width = this.mMapView.getWidth();
return (out.x < 0 || out.y < 0 || out.y > height || out.x > width);
}
@Override
public boolean isNearScreenEdge(GeoPoint lastPoint)
{
Point out = new Point();
this.mMapView.getProjection().toPixels(MapQuestLoggerMap.convertGeoPoint(lastPoint), out);
int height = this.mMapView.getHeight();
int width = this.mMapView.getWidth();
return (out.x < width / 4 || out.y < height / 4 || out.x > (width / 4) * 3 || out.y > (height / 4) * 3);
}
@Override
public void executePostponedActions()
{
}
@Override
public void enableCompass()
{
mMylocation.enableCompass();
}
@Override
public void enableMyLocation()
{
mMylocation.enableMyLocation();
}
@Override
public void disableMyLocation()
{
mMylocation.disableMyLocation();
}
@Override
public void disableCompass()
{
mMylocation.disableCompass();
}
@Override
public void setZoom(int zoom)
{
mMapView.getController().setZoom(zoom);
}
@Override
public void animateTo(GeoPoint storedPoint)
{
mMapView.getController().animateTo(MapQuestLoggerMap.convertGeoPoint(storedPoint));
}
@Override
public int getZoomLevel()
{
return mMapView.getZoomLevel();
}
@Override
public GeoPoint getMapCenter()
{
return MapQuestLoggerMap.convertMapQuestGeoPoint(mMapView.getMapCenter());
}
@Override
public boolean zoomOut()
{
return mMapView.getController().zoomOut();
}
@Override
public boolean zoomIn()
{
return mMapView.getController().zoomIn();
}
@Override
public void postInvalidate()
{
mMapView.postInvalidate();
}
@Override
public void addOverlay(OverlayProvider overlay)
{
mMapView.getOverlays().add(overlay.getMapQuestOverlay());
}
@Override
public void clearAnimation()
{
mMapView.clearAnimation();
}
@Override
public void setCenter(GeoPoint lastPoint)
{
mMapView.getController().setCenter( MapQuestLoggerMap.convertGeoPoint(lastPoint));
}
@Override
public int getMaxZoomLevel()
{
return mMapView.getMaxZoomLevel();
}
@Override
public GeoPoint fromPixels(int x, int y)
{
com.mapquest.android.maps.GeoPoint mqGeopoint = mMapView.getProjection().fromPixels(x, y);
return convertMapQuestGeoPoint(mqGeopoint);
}
@Override
public boolean hasProjection()
{
return mMapView.getProjection() != null;
}
@Override
public float metersToEquatorPixels(float float1)
{
return mMapView.getProjection().metersToEquatorPixels(float1);
}
@Override
public void toPixels(GeoPoint geoPoint, Point screenPoint)
{
com.mapquest.android.maps.GeoPoint mqGeopoint = MapQuestLoggerMap.convertGeoPoint(geoPoint);
mMapView.getProjection().toPixels( mqGeopoint, screenPoint);
}
@Override
public TextView[] getSpeedTextViews()
{
return mSpeedtexts;
}
@Override
public TextView getAltitideTextView()
{
return mLastGPSAltitudeView;
}
@Override
public TextView getSpeedTextView()
{
return mLastGPSSpeedView;
}
@Override
public TextView getDistanceTextView()
{
return mDistanceView;
}
static com.mapquest.android.maps.GeoPoint convertGeoPoint( GeoPoint point )
{
return new com.mapquest.android.maps.GeoPoint(point.getLatitudeE6(), point.getLongitudeE6() );
}
static GeoPoint convertMapQuestGeoPoint( com.mapquest.android.maps.GeoPoint mqPoint )
{
return new GeoPoint(mqPoint.getLatitudeE6(), mqPoint.getLongitudeE6() );
}
@Override
public void clearOverlays()
{
mMapView.getOverlays().clear();
}
@Override
public SlidingIndicatorView getScaleIndicatorView()
{
return (SlidingIndicatorView) findViewById(R.id.scaleindicator);
}
/******************************/
/** Own methods **/
/******************************/
@Override
public boolean isRouteDisplayed()
{
return true;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/MapQuestLoggerMap.java | Java | gpl3 | 10,898 |
/*
* Written by Pieter @ android-developers on groups.google.com
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.viewer.map.overlay;
import nl.sogeti.android.gpstracker.R;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.Point;
import android.graphics.drawable.Drawable;
import android.location.Location;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapView;
import com.google.android.maps.MyLocationOverlay;
import com.google.android.maps.Projection;
/**
* Fix for a ClassCastException found on some Google Maps API's implementations.
* @see <a href="http://www.spectrekking.com/download/FixedMyLocationOverlay.java">www.spectrekking.com</a>
* @version $Id$
*/
public class FixedMyLocationOverlay extends MyLocationOverlay {
private boolean bugged = false;
private Paint accuracyPaint;
private Point center;
private Point left;
private Drawable drawable;
private int width;
private int height;
public FixedMyLocationOverlay(Context context, MapView mapView) {
super(context, mapView);
}
@Override
protected void drawMyLocation(Canvas canvas, MapView mapView, Location lastFix, GeoPoint myLoc, long when) {
if (!bugged) {
try {
super.drawMyLocation(canvas, mapView, lastFix, myLoc, when);
} catch (Exception e) {
bugged = true;
}
}
if (bugged) {
if (drawable == null) {
if( accuracyPaint == null )
{
accuracyPaint = new Paint();
accuracyPaint.setAntiAlias(true);
accuracyPaint.setStrokeWidth(2.0f);
}
drawable = mapView.getContext().getResources().getDrawable(R.drawable.mylocation);
width = drawable.getIntrinsicWidth();
height = drawable.getIntrinsicHeight();
center = new Point();
left = new Point();
}
Projection projection = mapView.getProjection();
double latitude = lastFix.getLatitude();
double longitude = lastFix.getLongitude();
float accuracy = lastFix.getAccuracy();
float[] result = new float[1];
Location.distanceBetween(latitude, longitude, latitude, longitude + 1, result);
float longitudeLineDistance = result[0];
GeoPoint leftGeo = new GeoPoint((int)(latitude*1e6), (int)((longitude-accuracy/longitudeLineDistance)*1e6));
projection.toPixels(leftGeo, left);
projection.toPixels(myLoc, center);
int radius = center.x - left.x;
accuracyPaint.setColor(0xff6666ff);
accuracyPaint.setStyle(Style.STROKE);
canvas.drawCircle(center.x, center.y, radius, accuracyPaint);
accuracyPaint.setColor(0x186666ff);
accuracyPaint.setStyle(Style.FILL);
canvas.drawCircle(center.x, center.y, radius, accuracyPaint);
drawable.setBounds(center.x - width / 2, center.y - height / 2, center.x + width / 2, center.y + height / 2);
drawable.draw(canvas);
}
}
} | 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/overlay/FixedMyLocationOverlay.java | Java | gpl3 | 3,919 |
package nl.sogeti.android.gpstracker.viewer.map.overlay;
import nl.sogeti.android.gpstracker.viewer.map.LoggerMap;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;
import android.os.Handler;
import android.util.Log;
import android.view.MotionEvent;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapView;
import com.google.android.maps.Overlay;
public abstract class AsyncOverlay extends Overlay implements OverlayProvider
{
private static final int OFFSET = 20;
private static final String TAG = "GG.AsyncOverlay";
/**
* Handler provided by the MapActivity to recalculate graphics
*/
private Handler mHandler;
private GeoPoint mGeoTopLeft;
private GeoPoint mGeoBottumRight;
private int mWidth;
private int mHeight;
private Bitmap mActiveBitmap;
private GeoPoint mActiveTopLeft;
private Point mActivePointTopLeft;
private Bitmap mCalculationBitmap;
private Paint mPaint;
private LoggerMap mLoggerMap;
SegmentOsmOverlay mOsmOverlay;
private SegmentMapQuestOverlay mMapQuestOverlay;
private int mActiveZoomLevel;
private Runnable mBitmapUpdater = new Runnable()
{
@Override
public void run()
{
postedBitmapUpdater = false;
mCalculationBitmap.eraseColor(Color.TRANSPARENT);
mGeoTopLeft = mLoggerMap.fromPixels(0, 0);
mGeoBottumRight = mLoggerMap.fromPixels(mWidth, mHeight);
Canvas calculationCanvas = new Canvas(mCalculationBitmap);
redrawOffscreen(calculationCanvas, mLoggerMap);
synchronized (mActiveBitmap)
{
Bitmap oldActiveBitmap = mActiveBitmap;
mActiveBitmap = mCalculationBitmap;
mActiveTopLeft = mGeoTopLeft;
mCalculationBitmap = oldActiveBitmap;
}
mLoggerMap.postInvalidate();
}
};
private boolean postedBitmapUpdater;
AsyncOverlay(LoggerMap loggermap, Handler handler)
{
mLoggerMap = loggermap;
mHandler = handler;
mWidth = 1;
mHeight = 1;
mPaint = new Paint();
mActiveZoomLevel = -1;
mActiveBitmap = Bitmap.createBitmap(mWidth, mHeight, Bitmap.Config.ARGB_8888);
mActiveTopLeft = new GeoPoint(0, 0);
mActivePointTopLeft = new Point();
mCalculationBitmap = Bitmap.createBitmap(mWidth, mHeight, Bitmap.Config.ARGB_8888);
mOsmOverlay = new SegmentOsmOverlay(mLoggerMap.getActivity(), mLoggerMap, this);
mMapQuestOverlay = new SegmentMapQuestOverlay(this);
}
protected void reset()
{
synchronized (mActiveBitmap)
{
mCalculationBitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
mActiveBitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
}
}
protected void considerRedrawOffscreen()
{
int oldZoomLevel = mActiveZoomLevel;
mActiveZoomLevel = mLoggerMap.getZoomLevel();
boolean needNewCalculation = false;
if (mCalculationBitmap.getWidth() != mWidth || mCalculationBitmap.getHeight() != mHeight)
{
mCalculationBitmap = Bitmap.createBitmap(mWidth, mHeight, Bitmap.Config.ARGB_8888);
needNewCalculation = true;
}
boolean unaligned = isOutAlignment();
if (needNewCalculation || mActiveZoomLevel != oldZoomLevel || unaligned)
{
scheduleRecalculation();
}
}
private boolean isOutAlignment()
{
Point screenPoint = new Point(0, 0);
if (mGeoTopLeft != null)
{
mLoggerMap.toPixels(mGeoTopLeft, screenPoint);
}
return mGeoTopLeft == null || mGeoBottumRight == null || screenPoint.x > OFFSET || screenPoint.y > OFFSET || screenPoint.x < -OFFSET
|| screenPoint.y < -OFFSET;
}
public void onDateOverlayChanged()
{
if (!postedBitmapUpdater)
{
postedBitmapUpdater = true;
mHandler.post(mBitmapUpdater);
}
}
protected abstract void redrawOffscreen(Canvas asyncBuffer, LoggerMap loggermap);
protected abstract void scheduleRecalculation();
/**
* {@inheritDoc}
*/
@Override
public void draw(Canvas canvas, MapView mapView, boolean shadow)
{
if (!shadow)
{
draw(canvas);
}
}
private void draw(Canvas canvas)
{
mWidth = canvas.getWidth();
mHeight = canvas.getHeight();
considerRedrawOffscreen();
if (mActiveBitmap.getWidth() > 1)
{
synchronized (mActiveBitmap)
{
mLoggerMap.toPixels(mActiveTopLeft, mActivePointTopLeft);
canvas.drawBitmap(mActiveBitmap, mActivePointTopLeft.x, mActivePointTopLeft.y, mPaint);
}
}
}
protected boolean isPointOnScreen(Point point)
{
return point.x < 0 || point.y < 0 || point.x > mWidth || point.y > mHeight;
}
@Override
public boolean onTap(GeoPoint tappedGeoPoint, MapView mapview)
{
return commonOnTap(tappedGeoPoint);
}
/**************************************/
/** Multi map support **/
/**************************************/
@Override
public Overlay getGoogleOverlay()
{
return this;
}
@Override
public org.osmdroid.views.overlay.Overlay getOSMOverlay()
{
return mOsmOverlay;
}
@Override
public com.mapquest.android.maps.Overlay getMapQuestOverlay()
{
return mMapQuestOverlay;
}
protected abstract boolean commonOnTap(GeoPoint tappedGeoPoint);
static class SegmentOsmOverlay extends org.osmdroid.views.overlay.Overlay
{
AsyncOverlay mSegmentOverlay;
LoggerMap mLoggerMap;
public SegmentOsmOverlay(Context ctx, LoggerMap map, AsyncOverlay segmentOverlay)
{
super(ctx);
mLoggerMap = map;
mSegmentOverlay = segmentOverlay;
}
public AsyncOverlay getSegmentOverlay()
{
return mSegmentOverlay;
}
@Override
public boolean onSingleTapUp(MotionEvent e, org.osmdroid.views.MapView openStreetMapView)
{
int x = (int) e.getX();
int y = (int) e.getY();
GeoPoint tappedGeoPoint = mLoggerMap.fromPixels(x, y);
return mSegmentOverlay.commonOnTap(tappedGeoPoint);
}
@Override
protected void draw(Canvas canvas, org.osmdroid.views.MapView view, boolean shadow)
{
if (!shadow)
{
mSegmentOverlay.draw(canvas);
}
}
}
static class SegmentMapQuestOverlay extends com.mapquest.android.maps.Overlay
{
AsyncOverlay mSegmentOverlay;
public SegmentMapQuestOverlay(AsyncOverlay segmentOverlay)
{
super();
mSegmentOverlay = segmentOverlay;
}
public AsyncOverlay getSegmentOverlay()
{
return mSegmentOverlay;
}
@Override
public boolean onTap(com.mapquest.android.maps.GeoPoint p, com.mapquest.android.maps.MapView mapView)
{
GeoPoint tappedGeoPoint = new GeoPoint(p.getLatitudeE6(), p.getLongitudeE6());
return mSegmentOverlay.commonOnTap(tappedGeoPoint);
}
@Override
public void draw(Canvas canvas, com.mapquest.android.maps.MapView mapView, boolean shadow)
{
if (!shadow)
{
mSegmentOverlay.draw(canvas);
}
}
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/overlay/AsyncOverlay.java | Java | gpl3 | 7,453 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.viewer.map.overlay;
import com.mapquest.android.maps.Overlay;
public interface OverlayProvider
{
public com.google.android.maps.Overlay getGoogleOverlay();
public org.osmdroid.views.overlay.Overlay getOSMOverlay();
public Overlay getMapQuestOverlay();
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/overlay/OverlayProvider.java | Java | gpl3 | 1,824 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.viewer.map.overlay;
import java.text.DateFormat;
import java.util.Date;
import java.util.List;
import java.util.Vector;
import nl.sogeti.android.gpstracker.BuildConfig;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.db.GPStracking;
import nl.sogeti.android.gpstracker.db.GPStracking.Media;
import nl.sogeti.android.gpstracker.db.GPStracking.Waypoints;
import nl.sogeti.android.gpstracker.util.UnitsI18n;
import nl.sogeti.android.gpstracker.viewer.map.LoggerMap;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.database.ContentObserver;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ComposeShader;
import android.graphics.CornerPathEffect;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.PorterDuff.Mode;
import android.graphics.RadialGradient;
import android.graphics.Shader;
import android.graphics.Shader.TileMode;
import android.location.Location;
import android.net.Uri;
import android.os.Handler;
import android.util.Log;
import android.util.SparseArray;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.Toast;
import com.google.android.maps.GeoPoint;
import com.google.android.maps.MapView;
/**
* Creates an overlay that can draw a single segment of connected waypoints
*
* @version $Id$
* @author rene (c) Jan 11, 2009, Sogeti B.V.
*/
public class SegmentRendering
{
public static final int MIDDLE_SEGMENT = 0;
public static final int FIRST_SEGMENT = 1;
public static final int LAST_SEGMENT = 2;
public static final int DRAW_GREEN = 0;
public static final int DRAW_RED = 1;
public static final int DRAW_MEASURED = 2;
public static final int DRAW_CALCULATED = 3;
public static final int DRAW_DOTS = 4;
public static final int DRAW_HEIGHT = 5;
private static final String TAG = "OGT.SegmentRendering";
private static final float MINIMUM_PX_DISTANCE = 15;
private static SparseArray<Bitmap> sBitmapCache = new SparseArray<Bitmap>();;
private int mTrackColoringMethod = DRAW_CALCULATED;
private ContentResolver mResolver;
private LoggerMap mLoggerMap;
private int mPlacement = SegmentRendering.MIDDLE_SEGMENT;
private Uri mWaypointsUri;
private Uri mMediaUri;
private double mAvgSpeed;
private double mAvgHeight;
private GeoPoint mGeoTopLeft;
private GeoPoint mGeoBottumRight;
private Vector<DotVO> mDotPath;
private Vector<DotVO> mDotPathCalculation;
private Path mCalculatedPath;
private Point mCalculatedStart;
private Point mCalculatedStop;
private Path mPathCalculation;
private Shader mShader;
private Vector<MediaVO> mMediaPath;
private Vector<MediaVO> mMediaPathCalculation;
private GeoPoint mStartPoint;
private GeoPoint mEndPoint;
private Point mPrevDrawnScreenPoint;
private Point mScreenPointBackup;
private Point mScreenPoint;
private Point mMediaScreenPoint;
private int mStepSize = -1;
private Location mLocation;
private Location mPrevLocation;
private Cursor mWaypointsCursor;
private Cursor mMediaCursor;
private Uri mSegmentUri;
private int mWaypointCount = -1;
private int mWidth;
private int mHeight;
private GeoPoint mPrevGeoPoint;
private int mCurrentColor;
private Paint dotpaint;
private Paint radiusPaint;
private Paint routePaint;
private Paint defaultPaint;
private boolean mRequeryFlag;
private Handler mHandler;
private static Bitmap sStartBitmap;
private static Bitmap sStopBitmap;
private AsyncOverlay mAsyncOverlay;
private ContentObserver mTrackSegmentsObserver;
private final Runnable mMediaCalculator = new Runnable()
{
@Override
public void run()
{
SegmentRendering.this.calculateMediaAsync();
}
};
private final Runnable mTrackCalculator = new Runnable()
{
@Override
public void run()
{
SegmentRendering.this.calculateTrackAsync();
}
};
/**
* Constructor: create a new TrackingOverlay.
*
* @param loggermap
* @param segmentUri
* @param color
* @param avgSpeed
* @param handler
*/
public SegmentRendering(LoggerMap loggermap, Uri segmentUri, int color, double avgSpeed, double avgHeight, Handler handler)
{
super();
mHandler = handler;
mLoggerMap = loggermap;
mTrackColoringMethod = color;
mAvgSpeed = avgSpeed;
mAvgHeight = avgHeight;
mSegmentUri = segmentUri;
mMediaUri = Uri.withAppendedPath(mSegmentUri, "media");
mWaypointsUri = Uri.withAppendedPath(mSegmentUri, "waypoints");
mResolver = mLoggerMap.getActivity().getContentResolver();
mRequeryFlag = true;
mCurrentColor = Color.rgb(255, 0, 0);
dotpaint = new Paint();
radiusPaint = new Paint();
radiusPaint.setColor(Color.YELLOW);
radiusPaint.setAlpha(100);
routePaint = new Paint();
routePaint.setStyle(Paint.Style.STROKE);
routePaint.setStrokeWidth(6);
routePaint.setAntiAlias(true);
routePaint.setPathEffect(new CornerPathEffect(10));
defaultPaint = new Paint();
mScreenPoint = new Point();
mMediaScreenPoint = new Point();
mScreenPointBackup = new Point();
mPrevDrawnScreenPoint = new Point();
mDotPath = new Vector<DotVO>();
mDotPathCalculation = new Vector<DotVO>();
mCalculatedPath = new Path();
mPathCalculation = new Path();
mMediaPath = new Vector<MediaVO>();
mMediaPathCalculation = new Vector<MediaVO>();
mTrackSegmentsObserver = new ContentObserver(new Handler())
{
@Override
public void onChange(boolean selfUpdate)
{
if (!selfUpdate)
{
mRequeryFlag = true;
}
else
{
Log.w(TAG, "mTrackSegmentsObserver skipping change on " + mSegmentUri);
}
}
};
openResources();
}
public void closeResources()
{
mResolver.unregisterContentObserver(mTrackSegmentsObserver);
mHandler.removeCallbacks(mMediaCalculator);
mHandler.removeCallbacks(mTrackCalculator);
mHandler.postAtFrontOfQueue(new Runnable()
{
@Override
public void run()
{
if (mWaypointsCursor != null)
{
mWaypointsCursor.close();
mWaypointsCursor = null;
}
if (mMediaCursor != null)
{
mMediaCursor.close();
mMediaCursor = null;
}
}
});
SegmentRendering.sStopBitmap = null;
SegmentRendering.sStartBitmap = null;
}
public void openResources()
{
mResolver.registerContentObserver(mWaypointsUri, false, mTrackSegmentsObserver);
}
/**
* Private draw method called by both the draw from Google Overlay and the
* OSM Overlay
*
* @param canvas
*/
public void draw(Canvas canvas)
{
switch (mTrackColoringMethod)
{
case DRAW_HEIGHT:
case DRAW_CALCULATED:
case DRAW_MEASURED:
case DRAW_RED:
case DRAW_GREEN:
drawPath(canvas);
break;
case DRAW_DOTS:
drawDots(canvas);
break;
}
drawStartStopCircles(canvas);
drawMedia(canvas);
mWidth = canvas.getWidth();
mHeight = canvas.getHeight();
}
public void calculateTrack()
{
mHandler.removeCallbacks(mTrackCalculator);
mHandler.post(mTrackCalculator);
}
/**
* Either the Path or the Dots are calculated based on he current track
* coloring method
*/
private synchronized void calculateTrackAsync()
{
mGeoTopLeft = mLoggerMap.fromPixels(0, 0);
mGeoBottumRight = mLoggerMap.fromPixels(mWidth, mHeight);
calculateStepSize();
mScreenPoint.x = -1;
mScreenPoint.y = -1;
this.mPrevDrawnScreenPoint.x = -1;
this.mPrevDrawnScreenPoint.y = -1;
switch (mTrackColoringMethod)
{
case DRAW_HEIGHT:
case DRAW_CALCULATED:
case DRAW_MEASURED:
case DRAW_RED:
case DRAW_GREEN:
calculatePath();
synchronized (mCalculatedPath) // Switch the fresh path with the old Path object
{
Path oldPath = mCalculatedPath;
mCalculatedPath = mPathCalculation;
mPathCalculation = oldPath;
}
break;
case DRAW_DOTS:
calculateDots();
synchronized (mDotPath) // Switch the fresh path with the old Path object
{
Vector<DotVO> oldDotPath = mDotPath;
mDotPath = mDotPathCalculation;
mDotPathCalculation = oldDotPath;
}
break;
}
calculateStartStopCircles();
mAsyncOverlay.onDateOverlayChanged();
}
/**
* Calculated the new contents of segment in the mDotPathCalculation
*/
private void calculatePath()
{
mDotPathCalculation.clear();
this.mPathCalculation.rewind();
this.mShader = null;
GeoPoint geoPoint;
this.mPrevLocation = null;
if (mWaypointsCursor == null)
{
mWaypointsCursor = this.mResolver.query(this.mWaypointsUri, new String[] { Waypoints.LATITUDE, Waypoints.LONGITUDE, Waypoints.SPEED, Waypoints.TIME,
Waypoints.ACCURACY, Waypoints.ALTITUDE }, null, null, null);
mRequeryFlag = false;
}
if (mRequeryFlag)
{
mWaypointsCursor.requery();
mRequeryFlag = false;
}
if (mLoggerMap.hasProjection() && mWaypointsCursor.moveToFirst())
{
// Start point of the segments, possible a dot
this.mStartPoint = extractGeoPoint();
mPrevGeoPoint = mStartPoint;
this.mLocation = new Location(this.getClass().getName());
this.mLocation.setLatitude(mWaypointsCursor.getDouble(0));
this.mLocation.setLongitude(mWaypointsCursor.getDouble(1));
this.mLocation.setTime(mWaypointsCursor.getLong(3));
moveToGeoPoint(this.mStartPoint);
do
{
geoPoint = extractGeoPoint();
// Do no include log wrong 0.0 lat 0.0 long, skip to next value in while-loop
if (geoPoint.getLatitudeE6() == 0 || geoPoint.getLongitudeE6() == 0)
{
continue;
}
double speed = -1d;
switch (mTrackColoringMethod)
{
case DRAW_GREEN:
case DRAW_RED:
plainLineToGeoPoint(geoPoint);
break;
case DRAW_MEASURED:
speedLineToGeoPoint(geoPoint, mWaypointsCursor.getDouble(2));
break;
case DRAW_CALCULATED:
this.mPrevLocation = this.mLocation;
this.mLocation = new Location(this.getClass().getName());
this.mLocation.setLatitude(mWaypointsCursor.getDouble(0));
this.mLocation.setLongitude(mWaypointsCursor.getDouble(1));
this.mLocation.setTime(mWaypointsCursor.getLong(3));
speed = calculateSpeedBetweenLocations(this.mPrevLocation, this.mLocation);
speedLineToGeoPoint(geoPoint, speed);
break;
case DRAW_HEIGHT:
heightLineToGeoPoint(geoPoint, mWaypointsCursor.getDouble(5));
break;
default:
Log.w(TAG, "Unknown coloring method");
break;
}
}
while (moveToNextWayPoint());
this.mEndPoint = extractGeoPoint(); // End point of the segments, possible a dot
}
// Log.d( TAG, "transformSegmentToPath stop: points "+mCalculatedPoints+" from "+moves+" moves" );
}
/**
* @param canvas
* @param mapView
* @param shadow
* @see SegmentRendering#draw(Canvas, MapView, boolean)
*/
private void calculateDots()
{
mPathCalculation.reset();
mDotPathCalculation.clear();
if (mWaypointsCursor == null)
{
mWaypointsCursor = this.mResolver.query(this.mWaypointsUri, new String[] { Waypoints.LATITUDE, Waypoints.LONGITUDE, Waypoints.SPEED, Waypoints.TIME,
Waypoints.ACCURACY }, null, null, null);
}
if (mRequeryFlag)
{
mWaypointsCursor.requery();
mRequeryFlag = false;
}
if (mLoggerMap.hasProjection() && mWaypointsCursor.moveToFirst())
{
GeoPoint geoPoint;
mStartPoint = extractGeoPoint();
mPrevGeoPoint = mStartPoint;
do
{
geoPoint = extractGeoPoint();
// Do no include log wrong 0.0 lat 0.0 long, skip to next value in while-loop
if (geoPoint.getLatitudeE6() == 0 || geoPoint.getLongitudeE6() == 0)
{
continue;
}
setScreenPoint(geoPoint);
float distance = (float) distanceInPoints(this.mPrevDrawnScreenPoint, this.mScreenPoint);
if (distance > MINIMUM_PX_DISTANCE)
{
DotVO dotVO = new DotVO();
dotVO.x = this.mScreenPoint.x;
dotVO.y = this.mScreenPoint.y;
dotVO.speed = mWaypointsCursor.getLong(2);
dotVO.time = mWaypointsCursor.getLong(3);
dotVO.radius = mLoggerMap.metersToEquatorPixels(mWaypointsCursor.getFloat(4));
mDotPathCalculation.add(dotVO);
this.mPrevDrawnScreenPoint.x = this.mScreenPoint.x;
this.mPrevDrawnScreenPoint.y = this.mScreenPoint.y;
}
}
while (moveToNextWayPoint());
this.mEndPoint = extractGeoPoint();
DotVO pointVO = new DotVO();
pointVO.x = this.mScreenPoint.x;
pointVO.y = this.mScreenPoint.y;
pointVO.speed = mWaypointsCursor.getLong(2);
pointVO.time = mWaypointsCursor.getLong(3);
pointVO.radius = mLoggerMap.metersToEquatorPixels(mWaypointsCursor.getFloat(4));
mDotPathCalculation.add(pointVO);
}
}
public void calculateMedia()
{
mHandler.removeCallbacks(mMediaCalculator);
mHandler.post(mMediaCalculator);
}
public synchronized void calculateMediaAsync()
{
mMediaPathCalculation.clear();
if (mMediaCursor == null)
{
mMediaCursor = this.mResolver.query(this.mMediaUri, new String[] { Media.WAYPOINT, Media.URI }, null, null, null);
}
else
{
mMediaCursor.requery();
}
if (mLoggerMap.hasProjection() && mMediaCursor.moveToFirst())
{
GeoPoint lastPoint = null;
int wiggle = 0;
do
{
MediaVO mediaVO = new MediaVO();
mediaVO.waypointId = mMediaCursor.getLong(0);
mediaVO.uri = Uri.parse(mMediaCursor.getString(1));
Uri mediaWaypoint = ContentUris.withAppendedId(mWaypointsUri, mediaVO.waypointId);
Cursor waypointCursor = null;
try
{
waypointCursor = this.mResolver.query(mediaWaypoint, new String[] { Waypoints.LATITUDE, Waypoints.LONGITUDE }, null, null, null);
if (waypointCursor != null && waypointCursor.moveToFirst())
{
int microLatitude = (int) (waypointCursor.getDouble(0) * 1E6d);
int microLongitude = (int) (waypointCursor.getDouble(1) * 1E6d);
mediaVO.geopoint = new GeoPoint(microLatitude, microLongitude);
}
}
finally
{
if (waypointCursor != null)
{
waypointCursor.close();
}
}
if (isGeoPointOnScreen(mediaVO.geopoint))
{
mLoggerMap.toPixels(mediaVO.geopoint, this.mMediaScreenPoint);
if (mediaVO.geopoint.equals(lastPoint))
{
wiggle += 4;
}
else
{
wiggle = 0;
}
mediaVO.bitmapKey = getResourceForMedia(mLoggerMap.getActivity().getResources(), mediaVO.uri);
mediaVO.w = sBitmapCache.get(mediaVO.bitmapKey).getWidth();
mediaVO.h = sBitmapCache.get(mediaVO.bitmapKey).getHeight();
int left = (mediaVO.w * 3) / 7 + wiggle;
int up = (mediaVO.h * 6) / 7 - wiggle;
mediaVO.x = mMediaScreenPoint.x - left;
mediaVO.y = mMediaScreenPoint.y - up;
lastPoint = mediaVO.geopoint;
}
mMediaPathCalculation.add(mediaVO);
}
while (mMediaCursor.moveToNext());
}
synchronized (mMediaPath) // Switch the fresh path with the old Path object
{
Vector<MediaVO> oldmMediaPath = mMediaPath;
mMediaPath = mMediaPathCalculation;
mMediaPathCalculation = oldmMediaPath;
}
if (mMediaPathCalculation.size() != mMediaPath.size())
{
mAsyncOverlay.onDateOverlayChanged();
}
}
private void calculateStartStopCircles()
{
if ((this.mPlacement == FIRST_SEGMENT || this.mPlacement == FIRST_SEGMENT + LAST_SEGMENT) && this.mStartPoint != null)
{
if (sStartBitmap == null)
{
sStartBitmap = BitmapFactory.decodeResource(this.mLoggerMap.getActivity().getResources(), R.drawable.stip);
}
if (mCalculatedStart == null)
{
mCalculatedStart = new Point();
}
mLoggerMap.toPixels(this.mStartPoint, mCalculatedStart);
}
if ((this.mPlacement == LAST_SEGMENT || this.mPlacement == FIRST_SEGMENT + LAST_SEGMENT) && this.mEndPoint != null)
{
if (sStopBitmap == null)
{
sStopBitmap = BitmapFactory.decodeResource(this.mLoggerMap.getActivity().getResources(), R.drawable.stip2);
}
if (mCalculatedStop == null)
{
mCalculatedStop = new Point();
}
mLoggerMap.toPixels(this.mEndPoint, mCalculatedStop);
}
}
/**
* @param canvas
* @see SegmentRendering#draw(Canvas, MapView, boolean)
*/
private void drawPath(Canvas canvas)
{
switch (mTrackColoringMethod)
{
case DRAW_HEIGHT:
case DRAW_CALCULATED:
case DRAW_MEASURED:
routePaint.setShader(this.mShader);
break;
case DRAW_RED:
routePaint.setShader(null);
routePaint.setColor(Color.RED);
break;
case DRAW_GREEN:
routePaint.setShader(null);
routePaint.setColor(Color.GREEN);
break;
default:
routePaint.setShader(null);
routePaint.setColor(Color.YELLOW);
break;
}
synchronized (mCalculatedPath)
{
canvas.drawPath(mCalculatedPath, routePaint);
}
}
private void drawDots(Canvas canvas)
{
synchronized (mDotPath)
{
if (sStopBitmap == null)
{
sStopBitmap = BitmapFactory.decodeResource(this.mLoggerMap.getActivity().getResources(), R.drawable.stip2);
}
for (DotVO dotVO : mDotPath)
{
canvas.drawBitmap(sStopBitmap, dotVO.x - 8, dotVO.y - 8, dotpaint);
if (dotVO.radius > 8f)
{
canvas.drawCircle(dotVO.x, dotVO.y, dotVO.radius, radiusPaint);
}
}
}
}
private void drawMedia(Canvas canvas)
{
synchronized (mMediaPath)
{
for (MediaVO mediaVO : mMediaPath)
{
if (mediaVO.bitmapKey != null)
{
Log.d(TAG, "Draw bitmap at (" + mediaVO.x + ", " + mediaVO.y + ") on " + canvas);
canvas.drawBitmap(sBitmapCache.get(mediaVO.bitmapKey), mediaVO.x, mediaVO.y, defaultPaint);
}
}
}
}
private void drawStartStopCircles(Canvas canvas)
{
if (mCalculatedStart != null)
{
canvas.drawBitmap(sStartBitmap, mCalculatedStart.x - 8, mCalculatedStart.y - 8, defaultPaint);
}
if (mCalculatedStop != null)
{
canvas.drawBitmap(sStopBitmap, mCalculatedStop.x - 5, mCalculatedStop.y - 5, defaultPaint);
}
}
private Integer getResourceForMedia(Resources resources, Uri uri)
{
int drawable = 0;
if (uri.getScheme().equals("file"))
{
if (uri.getLastPathSegment().endsWith("3gp"))
{
drawable = R.drawable.media_film;
}
else if (uri.getLastPathSegment().endsWith("jpg"))
{
drawable = R.drawable.media_camera;
}
else if (uri.getLastPathSegment().endsWith("txt"))
{
drawable = R.drawable.media_notepad;
}
}
else if (uri.getScheme().equals("content"))
{
if (uri.getAuthority().equals(GPStracking.AUTHORITY + ".string"))
{
drawable = R.drawable.media_mark;
}
else if (uri.getAuthority().equals("media"))
{
drawable = R.drawable.media_speech;
}
}
Bitmap bitmap = null;
int bitmapKey = drawable;
synchronized (sBitmapCache)
{
if (sBitmapCache.get(bitmapKey) == null)
{
bitmap = BitmapFactory.decodeResource(resources, drawable);
sBitmapCache.put(bitmapKey, bitmap);
}
bitmap = sBitmapCache.get(bitmapKey);
}
return bitmapKey;
}
/**
* Set the mPlace to the specified value.
*
* @see SegmentRendering.FIRST
* @see SegmentRendering.MIDDLE
* @see SegmentRendering.LAST
* @param place The placement of this segment in the line.
*/
public void addPlacement(int place)
{
this.mPlacement += place;
}
public boolean isLast()
{
return (mPlacement >= LAST_SEGMENT);
}
public long getSegmentId()
{
return Long.parseLong(mSegmentUri.getLastPathSegment());
}
/**
* Set the beginnging to the next contour of the line to the give GeoPoint
*
* @param geoPoint
*/
private void moveToGeoPoint(GeoPoint geoPoint)
{
setScreenPoint(geoPoint);
if (this.mPathCalculation != null)
{
this.mPathCalculation.moveTo(this.mScreenPoint.x, this.mScreenPoint.y);
this.mPrevDrawnScreenPoint.x = this.mScreenPoint.x;
this.mPrevDrawnScreenPoint.y = this.mScreenPoint.y;
}
}
/**
* Line to point without shaders
*
* @param geoPoint
*/
private void plainLineToGeoPoint(GeoPoint geoPoint)
{
shaderLineToGeoPoint(geoPoint, 0, 0);
}
/**
* Line to point with speed
*
* @param geoPoint
* @param height
*/
private void heightLineToGeoPoint(GeoPoint geoPoint, double height)
{
shaderLineToGeoPoint(geoPoint, height, mAvgHeight);
}
/**
* Line to point with speed
*
* @param geoPoint
* @param speed
*/
private void speedLineToGeoPoint(GeoPoint geoPoint, double speed)
{
shaderLineToGeoPoint(geoPoint, speed, mAvgSpeed);
}
private void shaderLineToGeoPoint(GeoPoint geoPoint, double value, double average)
{
setScreenPoint(geoPoint);
// Log.d( TAG, "Draw line to " + geoPoint+" with speed "+speed );
if (value > 0)
{
int greenfactor = (int) Math.min((127 * value) / average, 255);
int redfactor = 255 - greenfactor;
mCurrentColor = Color.rgb(redfactor, greenfactor, 0);
}
else
{
int greenfactor = Color.green(mCurrentColor);
int redfactor = Color.red(mCurrentColor);
mCurrentColor = Color.argb(128, redfactor, greenfactor, 0);
}
float distance = (float) distanceInPoints(this.mPrevDrawnScreenPoint, this.mScreenPoint);
if (distance > MINIMUM_PX_DISTANCE)
{
// Log.d( TAG, "Circle between " + mPrevDrawnScreenPoint+" and "+mScreenPoint );
int x_circle = (this.mPrevDrawnScreenPoint.x + this.mScreenPoint.x) / 2;
int y_circle = (this.mPrevDrawnScreenPoint.y + this.mScreenPoint.y) / 2;
float radius_factor = 0.4f;
Shader lastShader = new RadialGradient(x_circle, y_circle, distance, new int[] { mCurrentColor, mCurrentColor, Color.TRANSPARENT }, new float[] { 0,
radius_factor, 0.6f }, TileMode.CLAMP);
// Paint debug = new Paint();
// debug.setStyle( Paint.Style.FILL_AND_STROKE );
// this.mDebugCanvas.drawCircle(
// x_circle,
// y_circle,
// distance*radius_factor/2,
// debug );
// this.mDebugCanvas.drawCircle(
// x_circle,
// y_circle,
// distance*radius_factor,
// debug );
// if( distance > 100 )
// {
// Log.d( TAG, "Created shader for speed " + speed + " on " + x_circle + "," + y_circle );
// }
if (this.mShader != null)
{
this.mShader = new ComposeShader(this.mShader, lastShader, Mode.DST_OVER);
}
else
{
this.mShader = lastShader;
}
this.mPrevDrawnScreenPoint.x = this.mScreenPoint.x;
this.mPrevDrawnScreenPoint.y = this.mScreenPoint.y;
}
this.mPathCalculation.lineTo(this.mScreenPoint.x, this.mScreenPoint.y);
}
/**
* Use to update location/point state when calculating the line
*
* @param geoPoint
*/
private void setScreenPoint(GeoPoint geoPoint)
{
mScreenPointBackup.x = this.mScreenPoint.x;
mScreenPointBackup.y = this.mScreenPoint.x;
mLoggerMap.toPixels(geoPoint, this.mScreenPoint);
}
/**
* Move to a next waypoint, for on screen this are the points with mStepSize
* % position == 0 to avoid jittering in the rendering or the points on the
* either side of the screen edge.
*
* @return if a next waypoint is pointed to with the mWaypointsCursor
*/
private boolean moveToNextWayPoint()
{
boolean cursorReady = true;
boolean onscreen = isGeoPointOnScreen(extractGeoPoint());
if (mWaypointsCursor.isLast()) // End of the line, cant move onward
{
cursorReady = false;
}
else if (onscreen) // Are on screen
{
cursorReady = moveOnScreenWaypoint();
}
else
// Are off screen => accelerate
{
int acceleratedStepsize = mStepSize * (mWaypointCount / 1000 + 6);
cursorReady = moveOffscreenWaypoint(acceleratedStepsize);
}
return cursorReady;
}
/**
* Move the cursor to the next waypoint modulo of the step size or less if
* the screen edge is reached
*
* @param trackCursor
* @return
*/
private boolean moveOnScreenWaypoint()
{
int nextPosition = mStepSize * (mWaypointsCursor.getPosition() / mStepSize) + mStepSize;
if (mWaypointsCursor.moveToPosition(nextPosition))
{
if (isGeoPointOnScreen(extractGeoPoint())) // Remained on screen
{
return true; // Cursor is pointing to somewhere
}
else
{
mWaypointsCursor.move(-1 * mStepSize); // Step back
boolean nowOnScreen = true; // onto the screen
while (nowOnScreen) // while on the screen
{
mWaypointsCursor.moveToNext(); // inch forward to the edge
nowOnScreen = isGeoPointOnScreen(extractGeoPoint());
}
return true; // with a cursor point to somewhere
}
}
else
{
return mWaypointsCursor.moveToLast(); // No full step can be taken, move to last
}
}
/**
* Previous path GeoPoint was off screen and the next one will be to or the
* first on screen when the path reaches the projection.
*
* @return
*/
private boolean moveOffscreenWaypoint(int flexStepsize)
{
while (mWaypointsCursor.move(flexStepsize))
{
if (mWaypointsCursor.isLast())
{
return true;
}
GeoPoint evalPoint = extractGeoPoint();
// Do no include log wrong 0.0 lat 0.0 long, skip to next value in while-loop
if (evalPoint.getLatitudeE6() == 0 || evalPoint.getLongitudeE6() == 0)
{
continue;
}
// Log.d( TAG, String.format( "Evaluate point number %d ", mWaypointsCursor.getPosition() ) );
if (possibleScreenPass(mPrevGeoPoint, evalPoint))
{
mPrevGeoPoint = evalPoint;
if (flexStepsize == 1) // Just stumbled over a border
{
return true;
}
else
{
mWaypointsCursor.move(-1 * flexStepsize); // Take 1 step back
return moveOffscreenWaypoint(flexStepsize / 2); // Continue at halve accelerated speed
}
}
else
{
moveToGeoPoint(evalPoint);
mPrevGeoPoint = evalPoint;
}
}
return mWaypointsCursor.moveToLast();
}
/**
* If a segment contains more then 500 waypoints and is zoomed out more then
* twice then some waypoints will not be used to render the line, this
* speeding things along.
*/
private void calculateStepSize()
{
Cursor waypointsCursor = null;
if (mRequeryFlag || mStepSize < 1 || mWaypointCount < 0)
{
try
{
waypointsCursor = this.mResolver.query(this.mWaypointsUri, new String[] { Waypoints._ID }, null, null, null);
mWaypointCount = waypointsCursor.getCount();
}
finally
{
if (waypointsCursor != null)
{
waypointsCursor.close();
}
}
}
if (mWaypointCount < 250)
{
mStepSize = 1;
}
else
{
int zoomLevel = mLoggerMap.getZoomLevel();
int maxZoomLevel = mLoggerMap.getMaxZoomLevel();
if (zoomLevel >= maxZoomLevel - 2)
{
mStepSize = 1;
}
else
{
mStepSize = maxZoomLevel - zoomLevel;
}
}
}
/**
* Is a given GeoPoint in the current projection of the map.
*
* @param eval
* @return
*/
protected boolean isGeoPointOnScreen(GeoPoint geopoint)
{
boolean onscreen = geopoint != null;
if (geopoint != null && mGeoTopLeft != null && mGeoBottumRight != null)
{
onscreen = onscreen && mGeoTopLeft.getLatitudeE6() > geopoint.getLatitudeE6();
onscreen = onscreen && mGeoBottumRight.getLatitudeE6() < geopoint.getLatitudeE6();
if (mGeoTopLeft.getLongitudeE6() < mGeoBottumRight.getLongitudeE6())
{
onscreen = onscreen && mGeoTopLeft.getLongitudeE6() < geopoint.getLongitudeE6();
onscreen = onscreen && mGeoBottumRight.getLongitudeE6() > geopoint.getLongitudeE6();
}
else
{
onscreen = onscreen && (mGeoTopLeft.getLongitudeE6() < geopoint.getLongitudeE6() || mGeoBottumRight.getLongitudeE6() > geopoint.getLongitudeE6());
}
}
return onscreen;
}
/**
* Is a given coordinates are on the screen
*
* @param eval
* @return
*/
protected boolean isOnScreen(int x, int y)
{
boolean onscreen = x > 0 && y > 0 && x < mWidth && y < mHeight;
return onscreen;
}
/**
* Calculates in which segment opposited to the projecting a geo point
* resides
*
* @param p1
* @return
*/
private int toSegment(GeoPoint p1)
{
// Log.d( TAG, String.format( "Comparing %s to points TL %s and BR %s", p1, mTopLeft, mBottumRight ));
int nr;
if (p1.getLongitudeE6() < mGeoTopLeft.getLongitudeE6()) // left
{
nr = 1;
}
else if (p1.getLongitudeE6() > mGeoBottumRight.getLongitudeE6()) // right
{
nr = 3;
}
else
// middle
{
nr = 2;
}
if (p1.getLatitudeE6() > mGeoTopLeft.getLatitudeE6()) // top
{
nr = nr + 0;
}
else if (p1.getLatitudeE6() < mGeoBottumRight.getLatitudeE6()) // bottom
{
nr = nr + 6;
}
else
// middle
{
nr = nr + 3;
}
return nr;
}
private boolean possibleScreenPass(GeoPoint fromGeo, GeoPoint toGeo)
{
boolean safe = true;
if (fromGeo != null && toGeo != null)
{
int from = toSegment(fromGeo);
int to = toSegment(toGeo);
switch (from)
{
case 1:
safe = to == 1 || to == 2 || to == 3 || to == 4 || to == 7;
break;
case 2:
safe = to == 1 || to == 2 || to == 3;
break;
case 3:
safe = to == 1 || to == 2 || to == 3 || to == 6 || to == 9;
break;
case 4:
safe = to == 1 || to == 4 || to == 7;
break;
case 5:
safe = false;
break;
case 6:
safe = to == 3 || to == 6 || to == 9;
break;
case 7:
safe = to == 1 || to == 4 || to == 7 || to == 8 || to == 9;
break;
case 8:
safe = to == 7 || to == 8 || to == 9;
break;
case 9:
safe = to == 3 || to == 6 || to == 7 || to == 8 || to == 9;
break;
default:
safe = false;
break;
}
// Log.d( TAG, String.format( "From %d to %d is safe: %s", from, to, safe ) );
}
return !safe;
}
public void setTrackColoringMethod(int coloring, double avgspeed, double avgHeight)
{
if (mTrackColoringMethod != coloring)
{
mTrackColoringMethod = coloring;
calculateTrack();
}
mAvgSpeed = avgspeed;
mAvgHeight = avgHeight;
}
/**
* For the current waypoint cursor returns the GeoPoint
*
* @return
*/
private GeoPoint extractGeoPoint()
{
int microLatitude = (int) (mWaypointsCursor.getDouble(0) * 1E6d);
int microLongitude = (int) (mWaypointsCursor.getDouble(1) * 1E6d);
return new GeoPoint(microLatitude, microLongitude);
}
/**
* @param startLocation
* @param endLocation
* @return speed in m/s between 2 locations
*/
private static double calculateSpeedBetweenLocations(Location startLocation, Location endLocation)
{
double speed = -1d;
if (startLocation != null && endLocation != null)
{
float distance = startLocation.distanceTo(endLocation);
float seconds = (endLocation.getTime() - startLocation.getTime()) / 1000f;
speed = distance / seconds;
// Log.d( TAG, "Found a speed of "+speed+ " over a distance of "+ distance+" in a time of "+seconds);
}
if (speed > 0)
{
return speed;
}
else
{
return -1d;
}
}
public static int extendPoint(int x1, int x2)
{
int diff = x2 - x1;
int next = x2 + diff;
return next;
}
private static double distanceInPoints(Point start, Point end)
{
int x = Math.abs(end.x - start.x);
int y = Math.abs(end.y - start.y);
return (double) Math.sqrt(x * x + y * y);
}
private boolean handleMediaTapList(List<Uri> tappedUri)
{
if (tappedUri.size() == 1)
{
return handleMedia(mLoggerMap.getActivity(), tappedUri.get(0));
}
else
{
BaseAdapter adapter = new MediaAdapter(mLoggerMap.getActivity(), tappedUri);
mLoggerMap.showMediaDialog(adapter);
return true;
}
}
public static boolean handleMedia(Context ctx, Uri mediaUri)
{
if (mediaUri.getScheme().equals("file"))
{
Intent intent = new Intent(android.content.Intent.ACTION_VIEW);
if (mediaUri.getLastPathSegment().endsWith("3gp"))
{
intent.setDataAndType(mediaUri, "video/3gpp");
ctx.startActivity(intent);
return true;
}
else if (mediaUri.getLastPathSegment().endsWith("jpg"))
{
//<scheme>://<authority><absolute path>
Uri.Builder builder = new Uri.Builder();
mediaUri = builder.scheme(mediaUri.getScheme()).authority(mediaUri.getAuthority()).path(mediaUri.getPath()).build();
intent.setDataAndType(mediaUri, "image/jpeg");
ctx.startActivity(intent);
return true;
}
else if (mediaUri.getLastPathSegment().endsWith("txt"))
{
intent.setDataAndType(mediaUri, "text/plain");
ctx.startActivity(intent);
return true;
}
}
else if (mediaUri.getScheme().equals("content"))
{
if (mediaUri.getAuthority().equals(GPStracking.AUTHORITY + ".string"))
{
String text = mediaUri.getLastPathSegment();
Toast toast = Toast.makeText(ctx, text, Toast.LENGTH_LONG);
toast.show();
return true;
}
else if (mediaUri.getAuthority().equals("media"))
{
ctx.startActivity(new Intent(Intent.ACTION_VIEW, mediaUri));
return true;
}
}
return false;
}
public boolean commonOnTap(GeoPoint tappedGeoPoint)
{
List<Uri> tappedUri = new Vector<Uri>();
Point tappedPoint = new Point();
mLoggerMap.toPixels(tappedGeoPoint, tappedPoint);
for (MediaVO media : mMediaPath)
{
if (media.x < tappedPoint.x && tappedPoint.x < media.x + media.w && media.y < tappedPoint.y && tappedPoint.y < media.y + media.h)
{
tappedUri.add(media.uri);
}
}
if (tappedUri.size() > 0)
{
return handleMediaTapList(tappedUri);
}
else
{
if (mTrackColoringMethod == DRAW_DOTS)
{
DotVO tapped = null;
synchronized (mDotPath) // Switch the fresh path with the old Path object
{
int w = 25;
for (DotVO dot : mDotPath)
{
// Log.d( TAG, "Compare ("+dot.x+","+dot.y+") with tap ("+tappedPoint.x+","+tappedPoint.y+")" );
if (dot.x - w < tappedPoint.x && tappedPoint.x < dot.x + w && dot.y - w < tappedPoint.y && tappedPoint.y < dot.y + w)
{
if (tapped == null)
{
tapped = dot;
}
else
{
tapped = dot.distanceTo(tappedPoint) < tapped.distanceTo(tappedPoint) ? dot : tapped;
}
}
}
}
if (tapped != null)
{
DateFormat timeFormat = android.text.format.DateFormat.getTimeFormat(mLoggerMap.getActivity().getApplicationContext());
String timetxt = timeFormat.format(new Date(tapped.time));
UnitsI18n units = new UnitsI18n(mLoggerMap.getActivity(), null);
double speed = units.conversionFromMetersPerSecond(tapped.speed);
String speedtxt = String.format("%.1f %s", speed, units.getSpeedUnit());
String text = mLoggerMap.getActivity().getString(R.string.time_and_speed, timetxt, speedtxt);
Toast toast = Toast.makeText(mLoggerMap.getActivity(), text, Toast.LENGTH_SHORT);
toast.show();
}
}
return false;
}
}
private static class MediaVO
{
@Override
public String toString()
{
return "MediaVO [bitmapKey=" + bitmapKey + ", uri=" + uri + ", geopoint=" + geopoint + ", x=" + x + ", y=" + y + ", w=" + w + ", h=" + h
+ ", waypointId=" + waypointId + "]";
}
public Integer bitmapKey;
public Uri uri;
public GeoPoint geopoint;
public int x;
public int y;
public int w;
public int h;
public long waypointId;
}
private static class DotVO
{
public long time;
public long speed;
public int x;
public int y;
public float radius;
public int distanceTo(Point tappedPoint)
{
return Math.abs(tappedPoint.x - this.x) + Math.abs(tappedPoint.y - this.y);
}
}
private class MediaAdapter extends BaseAdapter
{
private Context mContext;
private List<Uri> mTappedUri;
private int itemBackground;
public MediaAdapter(Context ctx, List<Uri> tappedUri)
{
mContext = ctx;
mTappedUri = tappedUri;
TypedArray a = mContext.obtainStyledAttributes(R.styleable.gallery);
itemBackground = a.getResourceId(R.styleable.gallery_android_galleryItemBackground, 0);
a.recycle();
}
@Override
public int getCount()
{
return mTappedUri.size();
}
@Override
public Object getItem(int position)
{
return mTappedUri.get(position);
}
@Override
public long getItemId(int position)
{
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent)
{
ImageView imageView = new ImageView(mContext);
imageView.setImageBitmap(sBitmapCache.get(getResourceForMedia(mLoggerMap.getActivity().getResources(), mTappedUri.get(position))));
imageView.setScaleType(ImageView.ScaleType.FIT_XY);
imageView.setBackgroundResource(itemBackground);
return imageView;
}
}
public void setBitmapHolder(AsyncOverlay bitmapOverlay)
{
mAsyncOverlay = bitmapOverlay;
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/overlay/SegmentRendering.java | Java | gpl3 | 44,404 |
package nl.sogeti.android.gpstracker.viewer.map.overlay;
import java.util.LinkedList;
import java.util.List;
import nl.sogeti.android.gpstracker.viewer.map.LoggerMap;
import android.graphics.Canvas;
import android.os.Handler;
import android.util.Log;
import com.google.android.maps.GeoPoint;
public class BitmapSegmentsOverlay extends AsyncOverlay
{
private static final String TAG = "GG.BitmapSegmentsOverlay";
List<SegmentRendering> mOverlays;
Handler mOverlayHandler;
public BitmapSegmentsOverlay(LoggerMap loggermap, Handler handler)
{
super(loggermap, handler);
mOverlays = new LinkedList<SegmentRendering>();
mOverlayHandler = handler;
}
@Override
synchronized protected void redrawOffscreen(Canvas asyncBuffer, LoggerMap loggermap)
{
for (SegmentRendering segment : mOverlays)
{
segment.draw(asyncBuffer);
}
}
@Override
public synchronized void scheduleRecalculation()
{
for (SegmentRendering segment : mOverlays)
{
segment.calculateMedia();
segment.calculateTrack();
}
}
@Override
synchronized protected boolean commonOnTap(GeoPoint tappedGeoPoint)
{
boolean handled = false;
for (SegmentRendering segment : mOverlays)
{
if (!handled)
{
handled = segment.commonOnTap(tappedGeoPoint);
}
}
return handled;
}
synchronized public void addSegment(SegmentRendering segment)
{
segment.setBitmapHolder(this);
mOverlays.add(segment);
}
synchronized public void clearSegments()
{
for (SegmentRendering segment : mOverlays)
{
segment.closeResources();
}
mOverlays.clear();
reset();
}
synchronized public void setTrackColoringMethod(int color, double speed, double height)
{
for (SegmentRendering segment : mOverlays)
{
segment.setTrackColoringMethod(color, speed, height);
}
scheduleRecalculation();
}
public int size()
{
return mOverlays.size();
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/overlay/BitmapSegmentsOverlay.java | Java | gpl3 | 2,092 |
/*------------------------------------------------------------------------------
** Ident: Delivery Center Java
** Author: rene
** Copyright: (c) Feb 26, 2012 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*/
package nl.sogeti.android.gpstracker.viewer.map;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.SlidingIndicatorView;
import nl.sogeti.android.gpstracker.viewer.map.overlay.OverlayProvider;
import org.osmdroid.api.IGeoPoint;
import org.osmdroid.tileprovider.tilesource.TileSourceFactory;
import org.osmdroid.tileprovider.util.CloudmadeUtil;
import org.osmdroid.views.MapView;
import org.osmdroid.views.MapView.Projection;
import org.osmdroid.views.overlay.MyLocationOverlay;
import org.osmdroid.views.overlay.Overlay;
import android.app.Activity;
import android.app.Dialog;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Point;
import android.os.Bundle;
import android.util.Log;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.BaseAdapter;
import android.widget.TextView;
import com.google.android.maps.GeoPoint;
/**
* ????
*
* @version $Id:$
* @author rene (c) Feb 26, 2012, Sogeti B.V.
*/
public class OsmLoggerMap extends Activity implements LoggerMap
{
protected static final String TAG = "OsmLoggerMap";
LoggerMapHelper mHelper;
private MapView mMapView;
private TextView[] mSpeedtexts;
private TextView mLastGPSSpeedView;
private TextView mLastGPSAltitudeView;
private TextView mDistanceView;
private MyLocationOverlay mMylocation;
private Projection mProjecton;
/**
* Called when the activity is first created.
*/
@Override
protected void onCreate(Bundle load)
{
super.onCreate(load);
setContentView(R.layout.map_osm);
mMapView = (MapView) findViewById(R.id.myMapView);
TextView[] speeds = { (TextView) findViewById(R.id.speedview05), (TextView) findViewById(R.id.speedview04), (TextView) findViewById(R.id.speedview03),
(TextView) findViewById(R.id.speedview02), (TextView) findViewById(R.id.speedview01), (TextView) findViewById(R.id.speedview00) };
mSpeedtexts = speeds;
mLastGPSSpeedView = (TextView) findViewById(R.id.currentSpeed);
mLastGPSAltitudeView = (TextView) findViewById(R.id.currentAltitude);
mDistanceView = (TextView) findViewById(R.id.currentDistance);
mHelper = new LoggerMapHelper(this);
mMapView.setBuiltInZoomControls(true);
mProjecton = mMapView.getProjection();
mHelper.onCreate(load);
mMylocation = new MyLocationOverlay(this, mMapView);
mMapView.getOverlays().add( new Overlay(this)
{
@Override
protected void draw(Canvas arg0, MapView map, boolean arg2)
{
Projection projecton = map.getProjection();
mProjecton = projecton;
IGeoPoint gepoint = map.getMapCenter();
Point point = projecton.toPixels(gepoint, null);
Log.d(TAG, "Found center ("+gepoint.getLatitudeE6()+","+gepoint.getLongitudeE6()+") matching screen point ("+point.x+","+point.y+") ");
}
} );
}
@Override
protected void onResume()
{
super.onResume();
mHelper.onResume();
}
@Override
protected void onPause()
{
mHelper.onPause();
super.onPause();
}
@Override
protected void onDestroy()
{
mHelper.onDestroy();
super.onDestroy();
}
@Override
public void onNewIntent(Intent newIntent)
{
mHelper.onNewIntent(newIntent);
}
@Override
protected void onRestoreInstanceState(Bundle load)
{
if (load != null)
{
super.onRestoreInstanceState(load);
}
mHelper.onRestoreInstanceState(load);
}
@Override
protected void onSaveInstanceState(Bundle save)
{
super.onSaveInstanceState(save);
mHelper.onSaveInstanceState(save);
}
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
boolean result = super.onCreateOptionsMenu(menu);
mHelper.onCreateOptionsMenu(menu);
return result;
}
@Override
public boolean onPrepareOptionsMenu(Menu menu)
{
mHelper.onPrepareOptionsMenu(menu);
return super.onPrepareOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item)
{
boolean handled = mHelper.onOptionsItemSelected(item);
if( !handled )
{
handled = super.onOptionsItemSelected(item);
}
return handled;
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent intent)
{
super.onActivityResult(requestCode, resultCode, intent);
mHelper.onActivityResult(requestCode, resultCode, intent);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event)
{
boolean propagate = true;
switch (keyCode)
{
default:
propagate = mHelper.onKeyDown(keyCode, event);
if( propagate )
{
propagate = super.onKeyDown(keyCode, event);
}
break;
}
return propagate;
}
@Override
protected Dialog onCreateDialog(int id)
{
Dialog dialog = mHelper.onCreateDialog(id);
if( dialog == null )
{
dialog = super.onCreateDialog(id);
}
return dialog;
}
@Override
protected void onPrepareDialog(int id, Dialog dialog)
{
mHelper.onPrepareDialog(id, dialog);
super.onPrepareDialog(id, dialog);
}
/******************************/
/** Own methods **/
/******************************/
private void setTrafficOverlay(boolean b)
{
SharedPreferences sharedPreferences = mHelper.getPreferences();
Editor editor = sharedPreferences.edit();
editor.putBoolean(Constants.TRAFFIC, b);
editor.commit();
}
private void setSatelliteOverlay(boolean b)
{
SharedPreferences sharedPreferences = mHelper.getPreferences();
Editor editor = sharedPreferences.edit();
editor.putBoolean(Constants.SATELLITE, b);
editor.commit();
}
/******************************/
/** Loggermap methods **/
/******************************/
@Override
public void updateOverlays()
{
SharedPreferences sharedPreferences = mHelper.getPreferences();
int renderer = sharedPreferences.getInt(Constants.OSMBASEOVERLAY, 0);
switch( renderer )
{
case Constants.OSM_CLOUDMADE:
CloudmadeUtil.retrieveCloudmadeKey(this.getApplicationContext());
mMapView.setTileSource(TileSourceFactory.CLOUDMADESTANDARDTILES);
break;
case Constants.OSM_MAKNIK:
mMapView.setTileSource(TileSourceFactory.MAPNIK);
break;
case Constants.OSM_CYCLE:
mMapView.setTileSource(TileSourceFactory.CYCLEMAP);
break;
default:
break;
}
}
@Override
public void setDrawingCacheEnabled(boolean b)
{
findViewById(R.id.mapScreen).setDrawingCacheEnabled(true);
}
@Override
public Activity getActivity()
{
return this;
}
@Override
public void onLayerCheckedChanged(int checkedId, boolean isChecked)
{
switch (checkedId)
{
case R.id.layer_google_satellite:
setSatelliteOverlay(true);
break;
case R.id.layer_google_regular:
setSatelliteOverlay(false);
break;
case R.id.layer_traffic:
setTrafficOverlay(isChecked);
break;
default:
break;
}
}
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
{
if (key.equals(Constants.TRAFFIC))
{
updateOverlays();
}
else if (key.equals(Constants.SATELLITE))
{
updateOverlays();
}
}
@Override
public Bitmap getDrawingCache()
{
return findViewById(R.id.mapScreen).getDrawingCache();
}
@Override
public void showMediaDialog(BaseAdapter mediaAdapter)
{
mHelper.showMediaDialog(mediaAdapter);
}
public void onDateOverlayChanged()
{
mMapView.postInvalidate();
}
@Override
public String getDataSourceId()
{
return LoggerMapHelper.GOOGLE_PROVIDER;
}
@Override
public boolean isOutsideScreen(GeoPoint lastPoint)
{
Point out = new Point();
mProjecton.toMapPixels(convertGeoPoint(lastPoint), out);
int height = this.mMapView.getHeight();
int width = this.mMapView.getWidth();
return (out.x < 0 || out.y < 0 || out.y > height || out.x > width);
}
@Override
public boolean isNearScreenEdge(GeoPoint lastPoint)
{
Point out = new Point();
mProjecton.toMapPixels(convertGeoPoint(lastPoint), out);
int height = this.mMapView.getHeight();
int width = this.mMapView.getWidth();
return (out.x < width / 4 || out.y < height / 4 || out.x > (width / 4) * 3 || out.y > (height / 4) * 3);
}
@Override
public void executePostponedActions()
{
// NOOP for Google Maps
}
@Override
public void enableCompass()
{
mMylocation.enableCompass();
}
@Override
public void enableMyLocation()
{
mMylocation.enableMyLocation();
}
@Override
public void disableMyLocation()
{
mMylocation.disableMyLocation();
}
@Override
public void disableCompass()
{
mMylocation.disableCompass();
}
@Override
public void setZoom(int zoom)
{
mMapView.getController().setZoom(zoom);
}
@Override
public void animateTo(GeoPoint storedPoint)
{
mMapView.getController().animateTo(convertGeoPoint(storedPoint));
}
@Override
public int getZoomLevel()
{
return mMapView.getZoomLevel();
}
@Override
public GeoPoint getMapCenter()
{
return convertOSMGeoPoint(mMapView.getMapCenter());
}
@Override
public boolean zoomOut()
{
return mMapView.getController().zoomOut();
}
@Override
public boolean zoomIn()
{
return mMapView.getController().zoomIn();
}
@Override
public void postInvalidate()
{
mMapView.postInvalidate();
}
@Override
public void addOverlay(OverlayProvider overlay)
{
mMapView.getOverlays().add(overlay.getOSMOverlay());
}
@Override
public void clearAnimation()
{
mMapView.clearAnimation();
}
@Override
public void setCenter(GeoPoint lastPoint)
{
mMapView.getController().setCenter( convertGeoPoint(lastPoint));
}
@Override
public int getMaxZoomLevel()
{
return mMapView.getMaxZoomLevel();
}
@Override
public GeoPoint fromPixels(int x, int y)
{
IGeoPoint osmGeopoint = mProjecton.fromPixels(x, y);
GeoPoint geopoint = convertOSMGeoPoint(osmGeopoint);
return geopoint;
}
@Override
public void toPixels(GeoPoint geoPoint, Point screenPoint)
{
org.osmdroid.util.GeoPoint localGeopoint = convertGeoPoint(geoPoint);
mProjecton.toMapPixels( localGeopoint, screenPoint);
}
@Override
public boolean hasProjection()
{
return mProjecton != null;
}
@Override
public float metersToEquatorPixels(float float1)
{
return mProjecton.metersToEquatorPixels(float1);
}
@Override
public TextView[] getSpeedTextViews()
{
return mSpeedtexts;
}
@Override
public TextView getAltitideTextView()
{
return mLastGPSAltitudeView;
}
@Override
public TextView getSpeedTextView()
{
return mLastGPSSpeedView;
}
@Override
public TextView getDistanceTextView()
{
return mDistanceView;
}
static org.osmdroid.util.GeoPoint convertGeoPoint( GeoPoint point )
{
org.osmdroid.util.GeoPoint geopoint = new org.osmdroid.util.GeoPoint(point.getLatitudeE6(), point.getLongitudeE6());
return geopoint;
}
static GeoPoint convertOSMGeoPoint( IGeoPoint point )
{
return new GeoPoint(point.getLatitudeE6(), point.getLongitudeE6() );
}
@Override
public void clearOverlays()
{
mMapView.getOverlayManager().clear();
}
@Override
public SlidingIndicatorView getScaleIndicatorView()
{
return (SlidingIndicatorView) findViewById(R.id.scaleindicator);
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/map/OsmLoggerMap.java | Java | gpl3 | 13,328 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.viewer;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.db.GPStracking;
import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.provider.LiveFolders;
/**
* Activity to build a data set to be shown in a live folder in a Android desktop
*
* @version $Id$
* @author rene (c) Mar 22, 2009, Sogeti B.V.
*/
public class TracksLiveFolder extends Activity
{
@Override
protected void onCreate( Bundle savedInstanceState )
{
this.setVisible( false );
super.onCreate( savedInstanceState );
final Intent intent = getIntent();
final String action = intent.getAction();
if( LiveFolders.ACTION_CREATE_LIVE_FOLDER.equals( action ) )
{
final Intent baseAction = new Intent( Intent.ACTION_VIEW, GPStracking.Tracks.CONTENT_URI );
Uri liveData = Uri.withAppendedPath( GPStracking.CONTENT_URI, "live_folders/tracks" );
final Intent createLiveFolder = new Intent();
createLiveFolder.setData( liveData );
createLiveFolder.putExtra( LiveFolders.EXTRA_LIVE_FOLDER_NAME, getString(R.string.track_list) );
createLiveFolder.putExtra( LiveFolders.EXTRA_LIVE_FOLDER_ICON, Intent.ShortcutIconResource.fromContext( this, R.drawable.live ) );
createLiveFolder.putExtra( LiveFolders.EXTRA_LIVE_FOLDER_DISPLAY_MODE, LiveFolders.DISPLAY_MODE_LIST );
createLiveFolder.putExtra( LiveFolders.EXTRA_LIVE_FOLDER_BASE_INTENT, baseAction );
setResult( RESULT_OK, createLiveFolder );
}
else
{
setResult( RESULT_CANCELED );
}
finish();
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/TracksLiveFolder.java | Java | gpl3 | 3,237 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.viewer;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.actions.DescribeTrack;
import nl.sogeti.android.gpstracker.actions.Statistics;
import nl.sogeti.android.gpstracker.actions.tasks.GpxParser;
import nl.sogeti.android.gpstracker.actions.utils.ProgressListener;
import nl.sogeti.android.gpstracker.adapter.BreadcrumbsAdapter;
import nl.sogeti.android.gpstracker.adapter.SectionedListAdapter;
import nl.sogeti.android.gpstracker.breadcrumbs.BreadcrumbsService;
import nl.sogeti.android.gpstracker.breadcrumbs.BreadcrumbsService.LocalBinder;
import nl.sogeti.android.gpstracker.db.DatabaseHelper;
import nl.sogeti.android.gpstracker.db.GPStracking;
import nl.sogeti.android.gpstracker.db.GPStracking.Tracks;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.Pair;
import nl.sogeti.android.gpstracker.viewer.map.CommonLoggerMap;
import nl.sogeti.android.gpstracker.viewer.map.LoggerMap;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.app.ListActivity;
import android.app.SearchManager;
import android.content.ActivityNotFoundException;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.ContextMenu;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.SimpleCursorAdapter;
import android.widget.TextView;
/**
* Show a list view of all tracks, also doubles for showing search results
*
* @version $Id$
* @author rene (c) Jan 11, 2009, Sogeti B.V.
*/
public class TrackList extends ListActivity implements ProgressListener
{
private static final String TAG = "OGT.TrackList";
private static final int MENU_DETELE = Menu.FIRST + 0;
private static final int MENU_SHARE = Menu.FIRST + 1;
private static final int MENU_RENAME = Menu.FIRST + 2;
private static final int MENU_STATS = Menu.FIRST + 3;
private static final int MENU_SEARCH = Menu.FIRST + 4;
private static final int MENU_VACUUM = Menu.FIRST + 5;
private static final int MENU_PICKER = Menu.FIRST + 6;
private static final int MENU_BREADCRUMBS = Menu.FIRST + 7;
public static final int DIALOG_FILENAME = Menu.FIRST + 22;
private static final int DIALOG_RENAME = Menu.FIRST + 23;
private static final int DIALOG_DELETE = Menu.FIRST + 24;
private static final int DIALOG_VACUUM = Menu.FIRST + 25;
private static final int DIALOG_IMPORT = Menu.FIRST + 26;
private static final int DIALOG_INSTALL = Menu.FIRST + 27;
protected static final int DIALOG_ERROR = Menu.FIRST + 28;
private static final int PICKER_OI = Menu.FIRST + 29;
private static final int DESCRIBE = Menu.FIRST + 30;
private BreadcrumbsAdapter mBreadcrumbAdapter;
private EditText mTrackNameView;
private Uri mDialogTrackUri;
private String mDialogCurrentName = "";
private String mErrorDialogMessage;
private Exception mErrorDialogException;
private Runnable mImportAction;
private String mImportTrackName;
private String mErrorTask;
/**
* Progress listener for the background tasks uploading to gobreadcrumbs
*/
private ProgressListener mExportListener;
private int mPausePosition;
private BreadcrumbsService mService;
boolean mBound = false;
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
getWindow().requestFeature(Window.FEATURE_PROGRESS);
this.setContentView(R.layout.tracklist);
displayIntent(getIntent());
ListView listView = getListView();
listView.setItemsCanFocus(true);
// Add the context menu (the long press thing)
registerForContextMenu(listView);
if (savedInstanceState != null)
{
getListView().setSelection(savedInstanceState.getInt("POSITION"));
}
IntentFilter filter = new IntentFilter();
filter.addAction(BreadcrumbsService.NOTIFY_DATA_SET_CHANGED);
registerReceiver(mReceiver, filter);
Intent service = new Intent(this, BreadcrumbsService.class);
startService(service);
}
@Override
protected void onStart()
{
super.onStart();
Intent intent = new Intent(this, BreadcrumbsService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}
@Override
protected void onResume()
{
if (mPausePosition != 0)
{
getListView().setSelection(mPausePosition);
}
super.onResume();
}
@Override
protected void onPause()
{
mPausePosition = getListView().getFirstVisiblePosition();
super.onPause();
}
@Override
protected void onStop()
{
if (mBound)
{
unbindService(mConnection);
mBound = false;
mService = null;
}
super.onStop();
}
@Override
protected void onDestroy()
{
if (isFinishing())
{
Intent service = new Intent(this, BreadcrumbsService.class);
stopService(service);
}
unregisterReceiver(mReceiver);
super.onDestroy();
}
@Override
public void onNewIntent(Intent newIntent)
{
displayIntent(newIntent);
}
/*
* (non-Javadoc)
* @see android.app.ListActivity#onRestoreInstanceState(android.os.Bundle)
*/
@Override
protected void onRestoreInstanceState(Bundle state)
{
super.onRestoreInstanceState(state);
mDialogTrackUri = state.getParcelable("URI");
mDialogCurrentName = state.getString("NAME");
mDialogCurrentName = mDialogCurrentName != null ? mDialogCurrentName : "";
getListView().setSelection(state.getInt("POSITION"));
}
/*
* (non-Javadoc)
* @see android.app.Activity#onSaveInstanceState(android.os.Bundle)
*/
@Override
protected void onSaveInstanceState(Bundle outState)
{
super.onSaveInstanceState(outState);
outState.putParcelable("URI", mDialogTrackUri);
outState.putString("NAME", mDialogCurrentName);
outState.putInt("POSITION", getListView().getFirstVisiblePosition());
}
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
boolean result = super.onCreateOptionsMenu(menu);
menu.add(ContextMenu.NONE, MENU_SEARCH, ContextMenu.NONE, android.R.string.search_go).setIcon(android.R.drawable.ic_search_category_default).setAlphabeticShortcut(SearchManager.MENU_KEY);
menu.add(ContextMenu.NONE, MENU_VACUUM, ContextMenu.NONE, R.string.menu_vacuum).setIcon(android.R.drawable.ic_menu_crop);
menu.add(ContextMenu.NONE, MENU_PICKER, ContextMenu.NONE, R.string.menu_picker).setIcon(android.R.drawable.ic_menu_add);
menu.add(ContextMenu.NONE, MENU_BREADCRUMBS, ContextMenu.NONE, R.string.dialog_breadcrumbsconnect).setIcon(android.R.drawable.ic_menu_revert);
return result;
}
@Override
public boolean onOptionsItemSelected(MenuItem item)
{
boolean handled = false;
switch (item.getItemId())
{
case MENU_SEARCH:
onSearchRequested();
handled = true;
break;
case MENU_VACUUM:
showDialog(DIALOG_VACUUM);
break;
case MENU_PICKER:
try
{
Intent intent = new Intent("org.openintents.action.PICK_FILE");
intent.putExtra("org.openintents.extra.TITLE", getString(R.string.dialog_import_picker));
intent.putExtra("org.openintents.extra.BUTTON_TEXT", getString(R.string.menu_picker));
startActivityForResult(intent, PICKER_OI);
}
catch (ActivityNotFoundException e)
{
showDialog(DIALOG_INSTALL);
}
break;
case MENU_BREADCRUMBS:
mService.removeAuthentication();
mService.clearAllCache();
mService.collectBreadcrumbsOauthToken();
break;
default:
handled = super.onOptionsItemSelected(item);
}
return handled;
}
@Override
protected void onListItemClick(ListView listView, View view, int position, long id)
{
super.onListItemClick(listView, view, position, id);
Object item = listView.getItemAtPosition(position);
if (item instanceof String)
{
if (Constants.BREADCRUMBS_CONNECT.equals(item))
{
mService.collectBreadcrumbsOauthToken();
}
}
else if (item instanceof Pair< ? , ? >)
{
@SuppressWarnings("unchecked")
final Pair<Integer, Integer> track = (Pair<Integer, Integer>) item;
if (track.first == Constants.BREADCRUMBS_TRACK_ITEM_VIEW_TYPE)
{
TextView tv = (TextView) view.findViewById(R.id.listitem_name);
mImportTrackName = tv.getText().toString();
mImportAction = new Runnable()
{
@Override
public void run()
{
mService.startDownloadTask(TrackList.this, TrackList.this, track);
}
};
showDialog(DIALOG_IMPORT);
}
}
else
{
Intent intent = new Intent();
Uri trackUri = ContentUris.withAppendedId(Tracks.CONTENT_URI, id);
intent.setData(trackUri);
ComponentName caller = this.getCallingActivity();
if (caller != null)
{
setResult(RESULT_OK, intent);
finish();
}
else
{
intent.setClass(this, CommonLoggerMap.class);
startActivity(intent);
}
}
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo)
{
if (menuInfo instanceof AdapterView.AdapterContextMenuInfo)
{
AdapterView.AdapterContextMenuInfo itemInfo = (AdapterView.AdapterContextMenuInfo) menuInfo;
TextView textView = (TextView) itemInfo.targetView.findViewById(R.id.listitem_name);
if (textView != null)
{
menu.setHeaderTitle(textView.getText());
}
Object listItem = getListAdapter().getItem(itemInfo.position);
if (listItem instanceof Cursor)
{
menu.add(0, MENU_STATS, 0, R.string.menu_statistics);
menu.add(0, MENU_SHARE, 0, R.string.menu_shareTrack);
menu.add(0, MENU_RENAME, 0, R.string.menu_renameTrack);
menu.add(0, MENU_DETELE, 0, R.string.menu_deleteTrack);
}
}
}
@Override
public boolean onContextItemSelected(MenuItem item)
{
boolean handled = false;
AdapterView.AdapterContextMenuInfo info;
try
{
info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
}
catch (ClassCastException e)
{
Log.e(TAG, "Bad menuInfo", e);
return handled;
}
Object listItem = getListAdapter().getItem(info.position);
if (listItem instanceof Cursor)
{
Cursor cursor = (Cursor) listItem;
mDialogTrackUri = ContentUris.withAppendedId(Tracks.CONTENT_URI, cursor.getLong(0));
mDialogCurrentName = cursor.getString(1);
mDialogCurrentName = mDialogCurrentName != null ? mDialogCurrentName : "";
switch (item.getItemId())
{
case MENU_DETELE:
{
showDialog(DIALOG_DELETE);
handled = true;
break;
}
case MENU_SHARE:
{
Intent actionIntent = new Intent(Intent.ACTION_RUN);
actionIntent.setDataAndType(mDialogTrackUri, Tracks.CONTENT_ITEM_TYPE);
actionIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
startActivity(Intent.createChooser(actionIntent, getString(R.string.share_track)));
handled = true;
break;
}
case MENU_RENAME:
{
showDialog(DIALOG_RENAME);
handled = true;
break;
}
case MENU_STATS:
{
Intent actionIntent = new Intent(this, Statistics.class);
actionIntent.setData(mDialogTrackUri);
startActivity(actionIntent);
handled = true;
break;
}
default:
handled = super.onContextItemSelected(item);
break;
}
}
return handled;
}
/*
* (non-Javadoc)
* @see android.app.Activity#onCreateDialog(int)
*/
@Override
protected Dialog onCreateDialog(int id)
{
Dialog dialog = null;
Builder builder = null;
switch (id)
{
case DIALOG_RENAME:
LayoutInflater factory = LayoutInflater.from(this);
View view = factory.inflate(R.layout.namedialog, null);
mTrackNameView = (EditText) view.findViewById(R.id.nameField);
builder = new AlertDialog.Builder(this).setTitle(R.string.dialog_routename_title).setMessage(R.string.dialog_routename_message).setIcon(android.R.drawable.ic_dialog_alert)
.setPositiveButton(R.string.btn_okay, mRenameOnClickListener).setNegativeButton(R.string.btn_cancel, null).setView(view);
dialog = builder.create();
return dialog;
case DIALOG_DELETE:
builder = new AlertDialog.Builder(TrackList.this).setTitle(R.string.dialog_delete_title).setIcon(android.R.drawable.ic_dialog_alert).setNegativeButton(android.R.string.cancel, null)
.setPositiveButton(android.R.string.ok, mDeleteOnClickListener);
dialog = builder.create();
String messageFormat = this.getResources().getString(R.string.dialog_delete_message);
String message = String.format(messageFormat, "");
((AlertDialog) dialog).setMessage(message);
return dialog;
case DIALOG_VACUUM:
builder = new AlertDialog.Builder(TrackList.this).setTitle(R.string.dialog_vacuum_title).setMessage(R.string.dialog_vacuum_message).setIcon(android.R.drawable.ic_dialog_alert)
.setNegativeButton(android.R.string.cancel, null).setPositiveButton(android.R.string.ok, mVacuumOnClickListener);
dialog = builder.create();
return dialog;
case DIALOG_IMPORT:
builder = new AlertDialog.Builder(TrackList.this).setTitle(R.string.dialog_import_title).setMessage(getString(R.string.dialog_import_message, mImportTrackName))
.setIcon(android.R.drawable.ic_dialog_alert).setNegativeButton(android.R.string.cancel, null).setPositiveButton(android.R.string.ok, mImportOnClickListener);
dialog = builder.create();
return dialog;
case DIALOG_INSTALL:
builder = new AlertDialog.Builder(this);
builder.setTitle(R.string.dialog_nooipicker).setMessage(R.string.dialog_nooipicker_message).setIcon(android.R.drawable.ic_dialog_alert)
.setPositiveButton(R.string.btn_install, mOiPickerDialogListener).setNegativeButton(R.string.btn_cancel, null);
dialog = builder.create();
return dialog;
case DIALOG_ERROR:
builder = new AlertDialog.Builder(this);
builder.setIcon(android.R.drawable.ic_dialog_alert).setTitle(android.R.string.dialog_alert_title).setMessage(mErrorDialogMessage).setNeutralButton(android.R.string.cancel, null);
dialog = builder.create();
return dialog;
default:
return super.onCreateDialog(id);
}
}
/*
* (non-Javadoc)
* @see android.app.Activity#onPrepareDialog(int, android.app.Dialog)
*/
@Override
protected void onPrepareDialog(int id, Dialog dialog)
{
super.onPrepareDialog(id, dialog);
AlertDialog alert;
String message;
switch (id)
{
case DIALOG_RENAME:
mTrackNameView.setText(mDialogCurrentName);
mTrackNameView.setSelection(0, mDialogCurrentName.length());
break;
case DIALOG_DELETE:
alert = (AlertDialog) dialog;
String messageFormat = this.getResources().getString(R.string.dialog_delete_message);
message = String.format(messageFormat, mDialogCurrentName);
alert.setMessage(message);
break;
case DIALOG_ERROR:
alert = (AlertDialog) dialog;
message = "Failed task:\n" + mErrorTask;
message += "\n\n";
message += "Reason:\n" + mErrorDialogMessage;
if (mErrorDialogException != null)
{
message += " (" + mErrorDialogException.getMessage() + ") ";
}
alert.setMessage(message);
break;
case DIALOG_IMPORT:
alert = (AlertDialog) dialog;
alert.setMessage(getString(R.string.dialog_import_message, mImportTrackName));
break;
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data)
{
if (resultCode != RESULT_CANCELED)
{
switch (requestCode)
{
case PICKER_OI:
new GpxParser(TrackList.this, TrackList.this).execute(data.getData());
break;
case DESCRIBE:
Uri trackUri = data.getData();
String name;
if (data.getExtras() != null && data.getExtras().containsKey(Constants.NAME))
{
name = data.getExtras().getString(Constants.NAME);
}
else
{
name = "shareToGobreadcrumbs";
}
mService.startUploadTask(TrackList.this, mExportListener, trackUri, name);
break;
default:
super.onActivityResult(requestCode, resultCode, data);
break;
}
}
else
{
if (requestCode == DESCRIBE)
{
mBreadcrumbAdapter.notifyDataSetChanged();
}
}
}
private void displayIntent(Intent intent)
{
final String queryAction = intent.getAction();
final String orderby = Tracks.CREATION_TIME + " DESC";
Cursor tracksCursor = null;
if (Intent.ACTION_SEARCH.equals(queryAction))
{
// Got to SEARCH a query for tracks, make a list
tracksCursor = doSearchWithIntent(intent);
}
else if (Intent.ACTION_VIEW.equals(queryAction))
{
final Uri uri = intent.getData();
if ("content".equals(uri.getScheme()) && GPStracking.AUTHORITY.equals(uri.getAuthority()))
{
// Got to VIEW a single track, instead hand it of to the LoggerMap
Intent notificationIntent = new Intent(this, LoggerMap.class);
notificationIntent.setData(uri);
startActivity(notificationIntent);
finish();
}
else if (uri.getScheme().equals("file") || uri.getScheme().equals("content"))
{
mImportTrackName = uri.getLastPathSegment();
// Got to VIEW a GPX filename
mImportAction = new Runnable()
{
@Override
public void run()
{
new GpxParser(TrackList.this, TrackList.this).execute(uri);
}
};
showDialog(DIALOG_IMPORT);
tracksCursor = managedQuery(Tracks.CONTENT_URI, new String[] { Tracks._ID, Tracks.NAME, Tracks.CREATION_TIME }, null, null, orderby);
}
else
{
Log.e(TAG, "Unable to VIEW " + uri);
}
}
else
{
// Got to nothing, make a list of everything
tracksCursor = managedQuery(Tracks.CONTENT_URI, new String[] { Tracks._ID, Tracks.NAME, Tracks.CREATION_TIME }, null, null, orderby);
}
displayCursor(tracksCursor);
}
private void displayCursor(Cursor tracksCursor)
{
SectionedListAdapter sectionedAdapter = new SectionedListAdapter(this);
String[] fromColumns = new String[] { Tracks.NAME, Tracks.CREATION_TIME, Tracks._ID };
int[] toItems = new int[] { R.id.listitem_name, R.id.listitem_from, R.id.bcSyncedCheckBox };
SimpleCursorAdapter trackAdapter = new SimpleCursorAdapter(this, R.layout.trackitem, tracksCursor, fromColumns, toItems);
mBreadcrumbAdapter = new BreadcrumbsAdapter(this, mService);
sectionedAdapter.addSection("Local", trackAdapter);
sectionedAdapter.addSection("www.gobreadcrumbs.com", mBreadcrumbAdapter);
// Enrich the track adapter with Breadcrumbs adapter data
trackAdapter.setViewBinder(new SimpleCursorAdapter.ViewBinder()
{
@Override
public boolean setViewValue(View view, final Cursor cursor, int columnIndex)
{
if (columnIndex == 0)
{
final long trackId = cursor.getLong(0);
final String trackName = cursor.getString(1);
// Show the check if Breadcrumbs is online
final CheckBox checkbox = (CheckBox) view;
final ProgressBar progressbar = (ProgressBar) ((View) view.getParent()).findViewById(R.id.bcExportProgress);
if (mService != null && mService.isAuthorized())
{
checkbox.setVisibility(View.VISIBLE);
// Disable the checkbox if marked online
boolean isOnline = mService.isLocalTrackSynced(trackId);
checkbox.setEnabled(!isOnline);
// Check the checkbox if determined synced
boolean isSynced = mService.isLocalTrackSynced(trackId);
checkbox.setOnCheckedChangeListener(null);
checkbox.setChecked(isSynced);
checkbox.setOnCheckedChangeListener(new OnCheckedChangeListener()
{
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked)
{
if (isChecked)
{
// Start a description of the track
Intent namingIntent = new Intent(TrackList.this, DescribeTrack.class);
namingIntent.setData(ContentUris.withAppendedId(Tracks.CONTENT_URI, trackId));
namingIntent.putExtra(Constants.NAME, trackName);
mExportListener = new ProgressListener()
{
@Override
public void setIndeterminate(boolean indeterminate)
{
progressbar.setIndeterminate(indeterminate);
}
@Override
public void started()
{
checkbox.setVisibility(View.INVISIBLE);
progressbar.setVisibility(View.VISIBLE);
}
@Override
public void finished(Uri result)
{
checkbox.setVisibility(View.VISIBLE);
progressbar.setVisibility(View.INVISIBLE);
progressbar.setIndeterminate(false);
}
@Override
public void setProgress(int value)
{
progressbar.setProgress(value);
}
@Override
public void showError(String task, String errorMessage, Exception exception)
{
TrackList.this.showError(task, errorMessage, exception);
}
};
startActivityForResult(namingIntent, DESCRIBE);
}
}
});
}
else
{
checkbox.setVisibility(View.INVISIBLE);
checkbox.setOnCheckedChangeListener(null);
}
return true;
}
return false;
}
});
setListAdapter(sectionedAdapter);
}
private Cursor doSearchWithIntent(final Intent queryIntent)
{
final String queryString = queryIntent.getStringExtra(SearchManager.QUERY);
Cursor cursor = managedQuery(Tracks.CONTENT_URI, new String[] { Tracks._ID, Tracks.NAME, Tracks.CREATION_TIME }, "name LIKE ?", new String[] { "%" + queryString + "%" }, null);
return cursor;
}
/*******************************************************************/
/** ProgressListener interface and UI actions (non-Javadoc) **/
/*******************************************************************/
@Override
public void setIndeterminate(boolean indeterminate)
{
setProgressBarIndeterminate(indeterminate);
}
@Override
public void started()
{
setProgressBarVisibility(true);
setProgress(Window.PROGRESS_START);
}
@Override
public void finished(Uri result)
{
setProgressBarVisibility(false);
setProgressBarIndeterminate(false);
}
@Override
public void showError(String task, String errorDialogMessage, Exception errorDialogException)
{
mErrorTask = task;
mErrorDialogMessage = errorDialogMessage;
mErrorDialogException = errorDialogException;
Log.e(TAG, errorDialogMessage, errorDialogException);
if (!isFinishing())
{
showDialog(DIALOG_ERROR);
}
setProgressBarVisibility(false);
setProgressBarIndeterminate(false);
}
private ServiceConnection mConnection = new ServiceConnection()
{
@Override
public void onServiceConnected(ComponentName className, IBinder service)
{
LocalBinder binder = (LocalBinder) service;
mService = binder.getService();
mBound = true;
mBreadcrumbAdapter.setService(mService);
}
@Override
public void onServiceDisconnected(ComponentName arg0)
{
mBound = false;
mService = null;
}
};
private OnClickListener mDeleteOnClickListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
getContentResolver().delete(mDialogTrackUri, null, null);
}
};
private OnClickListener mRenameOnClickListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
// Log.d( TAG, "Context item selected: "+mDialogUri+" with name "+mDialogCurrentName );
String trackName = mTrackNameView.getText().toString();
ContentValues values = new ContentValues();
values.put(Tracks.NAME, trackName);
TrackList.this.getContentResolver().update(mDialogTrackUri, values, null, null);
}
};
private OnClickListener mVacuumOnClickListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
DatabaseHelper helper = new DatabaseHelper(TrackList.this);
helper.vacuum();
}
};
private OnClickListener mImportOnClickListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
mImportAction.run();
}
};
private final DialogInterface.OnClickListener mOiPickerDialogListener = new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which)
{
Uri oiDownload = Uri.parse("market://details?id=org.openintents.filemanager");
Intent oiAboutIntent = new Intent(Intent.ACTION_VIEW, oiDownload);
try
{
startActivity(oiAboutIntent);
}
catch (ActivityNotFoundException e)
{
oiDownload = Uri.parse("http://openintents.googlecode.com/files/FileManager-1.1.3.apk");
oiAboutIntent = new Intent(Intent.ACTION_VIEW, oiDownload);
startActivity(oiAboutIntent);
}
}
};
private BroadcastReceiver mReceiver = new BroadcastReceiver()
{
@Override
public void onReceive(Context context, Intent intent)
{
if (BreadcrumbsService.NOTIFY_DATA_SET_CHANGED.equals(intent.getAction()))
{
mBreadcrumbAdapter.updateItemList();
}
}
};
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/TrackList.java | Java | gpl3 | 32,071 |
/*------------------------------------------------------------------------------
** Ident: Sogeti Smart Mobile Solutions
** Author: rene
** Copyright: (c) Apr 24, 2011 Sogeti Nederland B.V. All Rights Reserved.
**------------------------------------------------------------------------------
** Sogeti Nederland B.V. | No part of this file may be reproduced
** Distributed Software Engineering | or transmitted in any form or by any
** Lange Dreef 17 | means, electronic or mechanical, for the
** 4131 NJ Vianen | purpose, without the express written
** The Netherlands | permission of the copyright holder.
*------------------------------------------------------------------------------
*
* This file is part of OpenGPSTracker.
*
* OpenGPSTracker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenGPSTracker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenGPSTracker. If not, see <http://www.gnu.org/licenses/>.
*
*/
package nl.sogeti.android.gpstracker.viewer;
import java.util.regex.Pattern;
import nl.sogeti.android.gpstracker.R;
import nl.sogeti.android.gpstracker.util.Constants;
import nl.sogeti.android.gpstracker.util.UnitsI18n;
import android.content.SharedPreferences.Editor;
import android.os.Bundle;
import android.preference.EditTextPreference;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
/**
* Controller for the settings dialog
*
* @version $Id: ApplicationPreferenceActivity.java 1146 2011-11-05 11:36:51Z
* rcgroot $
* @author rene (c) Jan 18, 2009, Sogeti B.V.
*/
public class ApplicationPreferenceActivity extends PreferenceActivity
{
public static final String STREAMBROADCAST_PREFERENCE = "streambroadcast_distance";
public static final String UNITS_IMPLEMENT_WIDTH_PREFERENCE = "units_implement_width";
public static final String CUSTOMPRECISIONDISTANCE_PREFERENCE = "customprecisiondistance";
public static final String CUSTOMPRECISIONTIME_PREFERENCE = "customprecisiontime";
public static final String PRECISION_PREFERENCE = "precision";
public static final String CUSTOMUPLOAD_BACKLOG = "CUSTOMUPLOAD_BACKLOG";
public static final String CUSTOMUPLOAD_URL = "CUSTOMUPLOAD_URL";
private EditTextPreference time;
private EditTextPreference distance;
private EditTextPreference implentWidth;
private EditTextPreference streambroadcast_distance;
private EditTextPreference custumupload_backlog;
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.layout.settings);
ListPreference precision = (ListPreference) findPreference(PRECISION_PREFERENCE);
time = (EditTextPreference) findPreference(CUSTOMPRECISIONTIME_PREFERENCE);
distance = (EditTextPreference) findPreference(CUSTOMPRECISIONDISTANCE_PREFERENCE);
implentWidth = (EditTextPreference) findPreference(UNITS_IMPLEMENT_WIDTH_PREFERENCE);
streambroadcast_distance = (EditTextPreference) findPreference(STREAMBROADCAST_PREFERENCE);
custumupload_backlog = (EditTextPreference) findPreference(CUSTOMUPLOAD_BACKLOG);
setEnabledCustomValues(precision.getValue());
precision.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener()
{
@Override
public boolean onPreferenceChange(Preference preference, Object newValue)
{
setEnabledCustomValues(newValue);
return true;
}
});
implentWidth.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener()
{
@Override
public boolean onPreferenceChange(Preference preference, Object newValue)
{
String fpExpr = "\\d{1,4}([,\\.]\\d+)?";
return Pattern.matches(fpExpr, newValue.toString());
}
});
streambroadcast_distance.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener()
{
@Override
public boolean onPreferenceChange(Preference preference, Object newValue)
{
String fpExpr = "\\d{1,5}";
boolean matches = Pattern.matches(fpExpr, newValue.toString());
if (matches)
{
Editor editor = getPreferenceManager().getSharedPreferences().edit();
double value = new UnitsI18n(ApplicationPreferenceActivity.this).conversionFromLocalToMeters(Integer.parseInt(newValue.toString()));
editor.putFloat("streambroadcast_distance_meter", (float) value);
editor.commit();
}
return matches;
}
});
custumupload_backlog.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener()
{
@Override
public boolean onPreferenceChange(Preference preference, Object newValue)
{
String fpExpr = "\\d{1,3}";
return Pattern.matches(fpExpr, newValue.toString());
}
});
}
private void setEnabledCustomValues(Object newValue)
{
boolean customPresicion = Integer.toString(Constants.LOGGING_CUSTOM).equals(newValue);
time.setEnabled(customPresicion);
distance.setEnabled(customPresicion);
}
}
| 12030121070-gtrack | OpenGPSTracker/application/src/nl/sogeti/android/gpstracker/viewer/ApplicationPreferenceActivity.java | Java | gpl3 | 5,868 |
</html><head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/> </head>
<body>
<h4>Translations</h4>
Translations hosted by <a href="http://www.getlocalization.com/">Get Localization</a>.
<ul>
<li>Chinese: 安智网汉化, NetDragon Websoft</li>
<li>Danish: Martin Larsen</li>
<li>Dutch: René de Groot, zwets</li>
<li>English: René de Groot</li>
<li>French: Paul Meier, mvl87, Fabrice Veniard</li>
<li>Finnish: Jani Pesonen</li>
<li>German: Werner Bogula, SkryBav, doopdoop</li>
<li>Hindi: vibin_nair</li>
<li>Italian: Paul Meier</li>
<li>Polish: Marcin Kost, Michał Podbielski, Wojciech Maj</li>
<li>Russian: Yuri Zaitsev </li>
<li>Spanish: Alfonso Montero López, Diego</li>
<li>Swedish: Jesper Falk</li>
</ul>
<h4>Code</h4>
Code hosted by <a href="http://code.google.com/p/open-gpstracker/">Google Code</a>.
<ul>
<li>Application: René de Groot</li>
<li>Start at boot: Tom Van Braeckel</li>
</ul>
<h4>Images</h4>
<ul>
<li>Bubbles icons: ICONS etc. MySiteMyWay</li>
</ul>
</body></html> | 12030121070-gtrack | OpenGPSTracker/application/assets/contributions.html | HTML | gpl3 | 1,021 |
</html><head></head>
<body>
<div class="section-copyrights">
<h3>Copyright (c) 2008 Google Inc.</h3>
<h4>Apache License Version 2.0</h4>
<ul>
<li>UnicodeReader.java</li>
</ul>
<hr/>
<h3>Copyright (c) 2005-2008, The Android Open Source Project</h3>
<h4>Apache License Version 2.0</h4>
<ul>
<li>compass_arrow.png</li>
<li>compass_base.png</li>
<li>ic_maps_indicator_current_position.png</li>
<li>ic_media_play_mirrored.png</li>
<li>ic_media_play.png</li>
<li>ic_menu_info_details.png</li>
<li>ic_menu_mapmode.png</li>
<li>ic_menu_movie.png</li>
<li>ic_menu_picture.png</li>
<li>ic_menu_preferences.png</li>
<li>ic_menu_show_list.png</li>
<li>ic_menu_view.png</li>
<li>icon.png</li>
<li>speedindexbar.png</li>
<li>stip.gif</li>
<li>stip2.gif</li>
</ul>
<hr/>
<h3>Copyright 1999-2011 The Apache Software Foundation</h3>
<h4>Apache License Version 2.0</h4>
<ul>
<li>Apache HttpComponents Client</li>
<li>Apache HttpComponents Core</li>
<li>Apache HttpComponents Mime</li>
</ul>
<hr/>
<h3>Copyright (c) 2009 Matthias Kaeppler</h3>
<h4>Apache License Version 2.0</h4>
<ul>
<li>OAuth Signpost</li>
</ul>
<hr/>
</div>
<div class="section-content"><p>Apache License<br></br>Version 2.0, January 2004<br></br>
<a href="http://www.apache.org/licenses/">http://www.apache.org/licenses/</a> </p>
<p>TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION</p>
<p><strong><a name="definitions">1. Definitions</a></strong>.</p>
<p>"License" shall mean the terms and conditions for use, reproduction, and
distribution as defined by Sections 1 through 9 of this document.</p>
<p>"Licensor" shall mean the copyright owner or entity authorized by the
copyright owner that is granting the License.</p>
<p>"Legal Entity" shall mean the union of the acting entity and all other
entities that control, are controlled by, or are under common control with
that entity. For the purposes of this definition, "control" means (i) the
power, direct or indirect, to cause the direction or management of such
entity, whether by contract or otherwise, or (ii) ownership of fifty
percent (50%) or more of the outstanding shares, or (iii) beneficial
ownership of such entity.</p>
<p>"You" (or "Your") shall mean an individual or Legal Entity exercising
permissions granted by this License.</p>
<p>"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation source,
and configuration files.</p>
<p>"Object" form shall mean any form resulting from mechanical transformation
or translation of a Source form, including but not limited to compiled
object code, generated documentation, and conversions to other media types.</p>
<p>"Work" shall mean the work of authorship, whether in Source or Object form,
made available under the License, as indicated by a copyright notice that
is included in or attached to the work (an example is provided in the
Appendix below).</p>
<p>"Derivative Works" shall mean any work, whether in Source or Object form,
that is based on (or derived from) the Work and for which the editorial
revisions, annotations, elaborations, or other modifications represent, as
a whole, an original work of authorship. For the purposes of this License,
Derivative Works shall not include works that remain separable from, or
merely link (or bind by name) to the interfaces of, the Work and Derivative
Works thereof.</p>
<p>"Contribution" shall mean any work of authorship, including the original
version of the Work and any modifications or additions to that Work or
Derivative Works thereof, that is intentionally submitted to Licensor for
inclusion in the Work by the copyright owner or by an individual or Legal
Entity authorized to submit on behalf of the copyright owner. For the
purposes of this definition, "submitted" means any form of electronic,
verbal, or written communication sent to the Licensor or its
representatives, including but not limited to communication on electronic
mailing lists, source code control systems, and issue tracking systems that
are managed by, or on behalf of, the Licensor for the purpose of discussing
and improving the Work, but excluding communication that is conspicuously
marked or otherwise designated in writing by the copyright owner as "Not a
Contribution."</p>
<p>"Contributor" shall mean Licensor and any individual or Legal Entity on
behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.</p>
<p><strong><a name="copyright">2. Grant of Copyright License</a></strong>. Subject to the
terms and conditions of this License, each Contributor hereby grants to You
a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of, publicly
display, publicly perform, sublicense, and distribute the Work and such
Derivative Works in Source or Object form.</p>
<p><strong><a name="patent">3. Grant of Patent License</a></strong>. Subject to the terms
and conditions of this License, each Contributor hereby grants to You a
perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made, use,
offer to sell, sell, import, and otherwise transfer the Work, where such
license applies only to those patent claims licensable by such Contributor
that are necessarily infringed by their Contribution(s) alone or by
combination of their Contribution(s) with the Work to which such
Contribution(s) was submitted. If You institute patent litigation against
any entity (including a cross-claim or counterclaim in a lawsuit) alleging
that the Work or a Contribution incorporated within the Work constitutes
direct or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate as of the
date such litigation is filed.</p>
<p><strong><a name="redistribution">4. Redistribution</a></strong>. You may reproduce and
distribute copies of the Work or Derivative Works thereof in any medium,
with or without modifications, and in Source or Object form, provided that
You meet the following conditions:</p>
<ol>
<li>
<p>You must give any other recipients of the Work or Derivative Works a
copy of this License; and</p>
</li>
<li>
<p>You must cause any modified files to carry prominent notices stating
that You changed the files; and</p>
</li>
<li>
<p>You must retain, in the Source form of any Derivative Works that You
distribute, all copyright, patent, trademark, and attribution notices from
the Source form of the Work, excluding those notices that do not pertain to
any part of the Derivative Works; and</p>
</li>
<li>
<p>If the Work includes a "NOTICE" text file as part of its distribution,
then any Derivative Works that You distribute must include a readable copy
of the attribution notices contained within such NOTICE file, excluding
those notices that do not pertain to any part of the Derivative Works, in
at least one of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or documentation,
if provided along with the Derivative Works; or, within a display generated
by the Derivative Works, if and wherever such third-party notices normally
appear. The contents of the NOTICE file are for informational purposes only
and do not modify the License. You may add Your own attribution notices
within Derivative Works that You distribute, alongside or as an addendum to
the NOTICE text from the Work, provided that such additional attribution
notices cannot be construed as modifying the License.
You may add Your own copyright statement to Your modifications and may
provide additional or different license terms and conditions for use,
reproduction, or distribution of Your modifications, or for any such
Derivative Works as a whole, provided Your use, reproduction, and
distribution of the Work otherwise complies with the conditions stated in
this License.</p>
</li>
</ol>
<p><strong><a name="contributions">5. Submission of Contributions</a></strong>. Unless You
explicitly state otherwise, any Contribution intentionally submitted for
inclusion in the Work by You to the Licensor shall be under the terms and
conditions of this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify the
terms of any separate license agreement you may have executed with Licensor
regarding such Contributions.</p>
<p><strong><a name="trademarks">6. Trademarks</a></strong>. This License does not grant
permission to use the trade names, trademarks, service marks, or product
names of the Licensor, except as required for reasonable and customary use
in describing the origin of the Work and reproducing the content of the
NOTICE file.</p>
<p><strong><a name="no-warranty">7. Disclaimer of Warranty</a></strong>. Unless required by
applicable law or agreed to in writing, Licensor provides the Work (and
each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including,
without limitation, any warranties or conditions of TITLE,
NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You
are solely responsible for determining the appropriateness of using or
redistributing the Work and assume any risks associated with Your exercise
of permissions under this License.</p>
<p><strong><a name="no-liability">8. Limitation of Liability</a></strong>. In no event and
under no legal theory, whether in tort (including negligence), contract, or
otherwise, unless required by applicable law (such as deliberate and
grossly negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a result
of this License or out of the use or inability to use the Work (including
but not limited to damages for loss of goodwill, work stoppage, computer
failure or malfunction, or any and all other commercial damages or losses),
even if such Contributor has been advised of the possibility of such
damages.</p>
<p><strong><a name="additional">9. Accepting Warranty or Additional Liability</a></strong>.
While redistributing the Work or Derivative Works thereof, You may choose
to offer, and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this License.
However, in accepting such obligations, You may act only on Your own behalf
and on Your sole responsibility, not on behalf of any other Contributor,
and only if You agree to indemnify, defend, and hold each Contributor
harmless for any liability incurred by, or claims asserted against, such
Contributor by reason of your accepting any such warranty or additional
liability.</p>
<p>END OF TERMS AND CONDITIONS</p>
</body></html> | 12030121070-gtrack | OpenGPSTracker/application/assets/notices.html | HTML | gpl3 | 10,965 |
<html><head></head><body>
<p>
Open GPS Tracker is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
</p><p>
Open GPS Tracker is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
</p><p>
You should have received a copy of the GNU General Public License along with Open GPS Tracker. If not, see <a href="http://www.gnu.org/licenses/">http://www.gnu.org/licenses/</a>.
</p>
</body></html> | 12030121070-gtrack | OpenGPSTracker/application/assets/license_short.html | HTML | gpl3 | 729 |