Android example source code file (TrackerEntry.java)

This example Android source code file (TrackerEntry.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Android by Example" ^TM.

Java - Android tags/keywords

accuracy, altitude, android, bearing, content, database, entrytype, float, int_data, latitude, location, longitude, real_data, service, speed, string, string_data, tag, trackerentry

The TrackerEntry.java Android example source code

/*
 * Copyright (C) 2008 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 com.android.locationtracker.data;

import android.content.ContentValues;
import android.database.Cursor;
import android.location.Location;


/**
 * Class that holds a tracker entry. An entry can be either a valid location, or
 * a simple log msg
 *
 * It provides a concrete data structure to represent data stored in the
 * TrackerProvider
 */
class TrackerEntry {

    static final String TIMESTAMP = "Timestamp";
    static final String TAG = "Tag";
    static final String ENTRY_TYPE = "Type";

    private Location mLocation;
    private float mDistFromNetLocation;
    private String mLogMsg;

    static final String ID_COL = "_id";
    static final String ACCURACY = "Accuracy";
    static final String LATITUDE = "Latitude";
    static final String LONGITUDE = "Longitude";
    static final String ALTITUDE = "Altitude";
    static final String SPEED = "Speed";
    static final String BEARING = "Bearing";
    static final String DIST_NET_LOCATION = "DistFromNetLocation";
    static final String LOC_TIME = "LocationTime";
    static final String DEBUG_INFO = "DebugInfo";

    static final String STRING_DATA = "STRING";
    static final String INT_DATA = "INTEGER";
    static final String REAL_DATA = "REAL";
    static final String BLOB_DATA = "BLOB";

    static final String[] ATTRIBUTES = {
            ID_COL, TIMESTAMP, TAG, ENTRY_TYPE, ACCURACY, LATITUDE, LONGITUDE,
            ALTITUDE, SPEED, BEARING, DIST_NET_LOCATION, LOC_TIME, DEBUG_INFO};
    static final String[] ATTRIBUTES_DATA_TYPE = {
            INT_DATA + " PRIMARY KEY", STRING_DATA, STRING_DATA, STRING_DATA,
            REAL_DATA, REAL_DATA, REAL_DATA, REAL_DATA, REAL_DATA, REAL_DATA,
            REAL_DATA, INT_DATA, STRING_DATA};

    // location extra keys used to retrieve debug info
    private static final String NETWORK_LOCATION_SOURCE_KEY =
        "networkLocationSource";
    private static final String NETWORK_LOCATION_TYPE_KEY =
        "networkLocationType";
    private static final String[] LOCATION_DEBUG_KEYS = {
            NETWORK_LOCATION_SOURCE_KEY, NETWORK_LOCATION_TYPE_KEY};

    enum EntryType {
        LOCATION_TYPE, LOG_TYPE
    }

    private String mTimestamp;
    private String mTag;
    private EntryType mType;

    private TrackerEntry(String tag, EntryType type) {
        mType = type;
        mTag = tag;
        mLocation = null;
    }

    private TrackerEntry(Location loc) {
        this(loc.getProvider(), EntryType.LOCATION_TYPE);
        mLocation = new Location(loc);
    }

    /**
     * Creates a TrackerEntry from a Location
     */
    static TrackerEntry createEntry(Location loc, float distFromNetLocation) {
        TrackerEntry entry = new TrackerEntry(loc);

        String timestampVal = DateUtils.getCurrentKMLTimestamp();
        entry.setTimestamp(timestampVal);
        entry.setDistFromNetLocation(distFromNetLocation);
        return entry;
    }

    /**
     * Creates a TrackerEntry from a log msg
     */
    static TrackerEntry createEntry(String tag, String msg) {
        TrackerEntry entry = new TrackerEntry(tag, EntryType.LOG_TYPE);
        String timestampVal = DateUtils.getCurrentKMLTimestamp();
        entry.setTimestamp(timestampVal);
        entry.setLogMsg(msg);
        return entry;
    }

    private void setTimestamp(String timestamp) {
        mTimestamp = timestamp;
    }

    EntryType getType() {
        return mType;
    }

    private void setDistFromNetLocation(float distFromNetLocation) {
        mDistFromNetLocation = distFromNetLocation;
    }

    private void setLogMsg(String msg) {
        mLogMsg = msg;
    }

    private void setLocation(Location location) {
        mLocation = location;
    }

    String getTimestamp() {
        return mTimestamp;
    }

    String getTag() {
        return mTag;
    }

    Location getLocation() {
        return mLocation;
    }

    String getLogMsg() {
        return mLogMsg;
    }

    float getDistFromNetLocation() {
        return mDistFromNetLocation;
    }

    static void buildCreationString(StringBuilder builder) {
        if (ATTRIBUTES.length != ATTRIBUTES_DATA_TYPE.length) {
            throw new IllegalArgumentException(
                    "Attribute length does not match data type length");
        }
        for (int i = 0; i < ATTRIBUTES_DATA_TYPE.length; i++) {
            if (i != 0) {
                builder.append(", ");
            }
            builder.append(String.format("%s %s", ATTRIBUTES[i],
                    ATTRIBUTES_DATA_TYPE[i]));
        }
    }

    ContentValues getAsContentValues() {
        ContentValues cValues = new ContentValues(ATTRIBUTES.length);
        cValues.put(TIMESTAMP, mTimestamp);
        cValues.put(TAG, mTag);
        cValues.put(ENTRY_TYPE, mType.toString());
        if (mType == EntryType.LOCATION_TYPE) {
            cValues.put(LATITUDE, mLocation.getLatitude());
            cValues.put(LONGITUDE, mLocation.getLongitude());
            if (mLocation.hasAccuracy()) {
                cValues.put(ACCURACY, mLocation.getAccuracy());
            }
            if (mLocation.hasAltitude()) {
                cValues.put(ALTITUDE, mLocation.getAltitude());
            }
            if (mLocation.hasSpeed()) {
                cValues.put(SPEED, mLocation.getSpeed());
            }
            if (mLocation.hasBearing()) {
                cValues.put(BEARING, mLocation.getBearing());
            }
            cValues.put(DIST_NET_LOCATION, mDistFromNetLocation);
            cValues.put(LOC_TIME, mLocation.getTime());
            StringBuilder debugBuilder = new StringBuilder("");
            if (mLocation.getExtras() != null) {
                for (String key : LOCATION_DEBUG_KEYS) {
                    Object val = mLocation.getExtras().get(key);
                    if (val != null) {
                        debugBuilder.append(String.format("%s=%s; ", key, val
                                .toString()));
                    }
                }
            }
            cValues.put(DEBUG_INFO, debugBuilder.toString());
        } else {
            cValues.put(DEBUG_INFO, mLogMsg);
        }
        return cValues;
    }

    static TrackerEntry createEntry(Cursor cursor) {
        String timestamp = cursor.getString(cursor.getColumnIndex(TIMESTAMP));
        String tag = cursor.getString(cursor.getColumnIndex(TAG));
        String sType = cursor.getString(cursor.getColumnIndex(ENTRY_TYPE));
        TrackerEntry entry = new TrackerEntry(tag, EntryType.valueOf(sType));
        entry.setTimestamp(timestamp);
        if (entry.getType() == EntryType.LOCATION_TYPE) {
            Location location = new Location(tag);
            location.setLatitude(cursor.getFloat(cursor
                    .getColumnIndexOrThrow(LATITUDE)));
            location.setLongitude(cursor.getFloat(cursor
                    .getColumnIndexOrThrow(LONGITUDE)));

            Float accuracy = getNullableFloat(cursor, ACCURACY);
            if (accuracy != null) {
                location.setAccuracy(accuracy);
            }
            Float altitude = getNullableFloat(cursor, ALTITUDE);
            if (altitude != null) {
                location.setAltitude(altitude);
            }
            Float bearing = getNullableFloat(cursor, BEARING);
            if (bearing != null) {
                location.setBearing(bearing);
            }
            Float speed = getNullableFloat(cursor, SPEED);
            if (speed != null) {
                location.setSpeed(speed);
            }
            location.setTime(cursor.getLong(cursor.getColumnIndex(LOC_TIME)));
            entry.setLocation(location);
        }
        entry.setLogMsg(cursor.getString(cursor.getColumnIndex(DEBUG_INFO)));

        return entry;
    }

    private static Float getNullableFloat(Cursor cursor, String colName) {
        Float retValue = null;
        int colIndex = cursor.getColumnIndexOrThrow(colName);
        if (!cursor.isNull(colIndex)) {
            retValue = cursor.getFloat(colIndex);
        }
        return retValue;
    }
}