ProximityActivity.java :  » Geo » geohunter » org » geohunter » activity » prox » Android Open Source

/*
 ** 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.geohunter.activity.prox;

import org.geohunter.GeocacheFilter;
import org.geohunter.GeoFix;
import org.geohunter.GeoFixProvider;
import org.geohunter.Geocache;
import org.geohunter.GeocacheFactory;
import org.geohunter.GeoFixProviderDI;
import org.geohunter.Refresher;
import org.geohunter.activity.filterlist.FilterTypeCollection;
import org.geohunter.activity.prox.ProximityPainter;
import org.geohunter.database.CachesProviderCount;
import org.geohunter.database.CachesProviderDb;
import org.geohunter.database.DatabaseLocator;
import org.geohunter.database.DbFrontend;

import android.app.Activity;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.SurfaceHolder;

public class ProximityActivity extends Activity implements SurfaceHolder.Callback {

    class DataCollector implements Refresher {
        @Override
        public void forceRefresh() {
            refresh();
        }

        @Override
        public void refresh() {
            mProximityPainter.setUserDirection(mGeoFixProvider.getAzimuth());
            GeoFix location = mGeoFixProvider.getLocation();
            mProximityPainter.setUserLocation(location.getLatitude(),
                    location.getLongitude(), location.getAccuracy());
        }
    }
    
    private ProximityView mProximityView;
    ProximityPainter mProximityPainter;
    DataCollector mDataCollector;
    private AnimatorThread mAnimatorThread;
    private boolean mStartWhenSurfaceCreated = false;  //TODO: Is mStartWhenSurfaceCreated needed?
    private DbFrontend mDbFrontend;
    private GeoFixProvider mGeoFixProvider;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        GeocacheFactory geocacheFactory = new GeocacheFactory();
        mDbFrontend = new DbFrontend(DatabaseLocator.getDatabasePath(), geocacheFactory);
        CachesProviderDb cachesProviderDb = new CachesProviderDb(mDbFrontend);
        final FilterTypeCollection filterTypeCollection = new FilterTypeCollection(this);
        GeocacheFilter cacheFilter = filterTypeCollection.getActiveFilter();
        cachesProviderDb.setFilter(cacheFilter);
        CachesProviderCount cachesProviderCount = new CachesProviderCount(cachesProviderDb, 5, 10);
        
        mProximityPainter = new ProximityPainter(cachesProviderCount);
        
        //Set metric or English units.
        final SharedPreferences sharedPreferences = 
            PreferenceManager.getDefaultSharedPreferences(this);
        final boolean mImperial= sharedPreferences.getBoolean("imperial", false);
        mProximityPainter.setUseImperial(mImperial);

        mProximityView = new ProximityView(this);
        setContentView(mProximityView);
    }

    @Override
    protected void onStart() {
        super.onStart();
        SurfaceHolder holder = mProximityView.getHolder();
        holder.addCallback(this); 
        mDataCollector = new DataCollector();
        mGeoFixProvider = GeoFixProviderDI.create(this);
        mGeoFixProvider.addObserver(mDataCollector);
    }
    
    @Override
    protected void onResume() {
        super.onResume();
        
        String id = getIntent().getStringExtra(Geocache.ID);
        if (!id.equals("")) {
            Geocache geocache = mDbFrontend.loadCacheFromId(id);
            mProximityPainter.setSelectedGeocache(geocache);
        }

        mGeoFixProvider.startUpdates();
        
        GeoFix location = mGeoFixProvider.getLocation();
        mProximityPainter.setUserLocation(location.getLatitude(), location.getLongitude(), location.getAccuracy());
        
        if (mAnimatorThread == null)
            mStartWhenSurfaceCreated = true;
        else
            mAnimatorThread.start();
    }
    
    @Override
    protected void onPause() {
        super.onPause();
        mGeoFixProvider.stopUpdates();
        if (mAnimatorThread != null) {
            AnimatorThread.IThreadStoppedListener listener = new
            AnimatorThread.IThreadStoppedListener() {
                @Override
                public void OnThreadStopped() {
                    mDbFrontend.closeDatabase();
                }
            };
            mAnimatorThread.stop(listener);
        }
    }
    
    
    // ***********************************
    // ** Implement SurfaceHolder.Callback **
    
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
                               int height) {
        Log.d("geohunter", "surfaceChanged called ("+width+"x"+height+")");
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        Log.d("geohunter", "surfaceCreated called");
        mAnimatorThread = new AnimatorThread(holder, mProximityPainter);
        if (mStartWhenSurfaceCreated) {
            mStartWhenSurfaceCreated = false;
            mAnimatorThread.start();
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        Log.d("geohunter", "surfaceDestroyed called");
    }

}