Android Open Source - geoar-app Geo A R Application

• Back to Location/Application  ↑

From Project

Back to project page geoar-app.

License

The source code is released under:

Apache License

Java Source Code

/**
 * Copyright 2012 52North Initiative for Geospatial Open Source Software GmbH
 *//from   w  w  w  . j  a  v a  2  s .  c om
 * 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.n52.geoar;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.ArrayList;
import java.util.List;

import org.n52.geoar.utils.DataSourceLoggerFactory;
import org.n52.geoar.utils.DataSourceLoggerFactory.LoggerCallable;
import org.n52.geoar.newdata.PluginLogger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import android.app.Activity;
import android.app.Application;
import android.content.ActivityNotFoundException;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.widget.Toast;

public class GeoARApplication extends Application {
  private static Logger LOG;

  public static Context applicationContext;

  public static final String PREFERENCES_FILE = "GeoAR";
  private static final String STACKTRACE_FILENAME = "stacktrace.log";
  private static final String LOG_FILEPATH = "logs/logfile.txt";
  private static final String REPORT_EMAIL = "geoar@52north.org";

  private UncaughtExceptionHandler defaultUncaughtExceptionHandler;

  private static File stacktraceFile;
  private static File logFile;

  @Override
  public void onCreate() {
    // Store application Context as static field
    applicationContext = getApplicationContext();

    // File to save uncaught exception trace to
    stacktraceFile = new File(applicationContext.getFilesDir(),
        STACKTRACE_FILENAME);
    // File path to logfile
    logFile = new File(applicationContext.getFilesDir() + "/"
        + LOG_FILEPATH);
    // Set system properties with log file, logback config references to
    // these,
    // so do not use LoggerFactory before this point
    System.setProperty("LOG_DIR", logFile.getParent());
    int sepIndex = logFile.getName().lastIndexOf(".");
    System.setProperty("LOG_NAME", logFile.getName().substring(0, sepIndex));
    System.setProperty("LOG_EXT", logFile.getName().substring(sepIndex + 1));

    LOG = LoggerFactory.getLogger(GeoARApplication.class);

    // Set uncaught exception handler
    defaultUncaughtExceptionHandler = Thread
        .getDefaultUncaughtExceptionHandler();
    Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {

      @Override
      public void uncaughtException(Thread thread, Throwable ex) {
        LOG.error("Uncaught exception in thread " + thread.getName(),
            ex);
        try {
          FileOutputStream fos = openFileOutput(STACKTRACE_FILENAME,
              Context.MODE_PRIVATE);
          ex.printStackTrace(new PrintStream(fos));
          fos.close();
        } catch (FileNotFoundException e) {
          e.printStackTrace();
        } catch (IOException e) {
          e.printStackTrace();
        }

        // fall back to standard handler
        if (defaultUncaughtExceptionHandler != null) {
          defaultUncaughtExceptionHandler.uncaughtException(thread,
              ex);
        }
      }
    });

    // ensure that plugins can access the main logger
    DataSourceLoggerFactory.setLoggerCallable(new LoggerCallable() {
      @Override
      public org.n52.geoar.utils.DataSourceLoggerFactory.Logger call(
          Class<?> clazz) {
        return new PluginLogger(clazz);
      }
    });

    super.onCreate();
  }

  /**
   * Checks if there is a recorded stacktrace
   */
  public static boolean checkAppFailed() {
    return stacktraceFile.exists();
  }

  /**
   * Deletes latest stacktrace record
   */
  public static void clearAppFailed() {
    if (!checkAppFailed())
      return;

    new File(applicationContext.getFilesDir(), STACKTRACE_FILENAME)
        .delete();
  }

  /**
   * Creates an {@link Intent#ACTION_SEND_MULTIPLE} Intent to create an email
   * with last stacktrace and current logfiles as attachments.
   * 
   * @param context
   */
  public static void sendFailMail(Activity context) {
    List<File> attachments = new ArrayList<File>();
    if (checkAppFailed()) {
      attachments.add(stacktraceFile);
    }

    if (logFile.exists()) {
      attachments.add(logFile);
    }
    sendMail(context, "GeoAR Error Report",
        applicationContext.getString(R.string.text_error_report),
        attachments);
  }

  /**
   * Copies specified {@link File}s to globally readable locations and returns
   * their {@link Uri}s
   * 
   * @param attachments
   * @return
   * @throws IOException
   */
  private static ArrayList<Uri> getFailAttachments(List<File> attachments)
      throws IOException {
    ArrayList<Uri> copiesUris = new ArrayList<Uri>(attachments.size());
    for (int i = 0, attachmentsSize = attachments.size(); i < attachmentsSize; i++) {

      InputStream inputStream = new FileInputStream(attachments.get(i));
      int sepIndex = attachments.get(i).getName().lastIndexOf(".");
      attachments.get(i).getName().substring(sepIndex);

      File fileCopy = new File(
          applicationContext.getExternalFilesDir(null), "fail_"
              + i
              + attachments.get(i).getName()
                  .substring(sepIndex + 1));
      copiesUris.add(Uri.fromFile(fileCopy));
      OutputStream outputStream = new FileOutputStream(fileCopy);

      byte[] buf = new byte[4096];
      int len;
      while ((len = inputStream.read(buf)) > 0) {
        outputStream.write(buf, 0, len);
      }
      inputStream.close();
      outputStream.close();
    }

    return copiesUris;
  }

  public static void sendFeedbackMail(Activity context) {
    List<File> attachments = new ArrayList<File>();
    if (logFile.exists()) {
      attachments.add(logFile);
    }
    sendMail(context, "GeoAR Feedback Report",
        applicationContext.getString(R.string.text_feedback_report),
        attachments);
  }

  private static void sendMail(Activity context, String subject,
      String message, List<File> attachments) {
    Intent intent = new Intent(Intent.ACTION_SEND_MULTIPLE);
    intent.setType("text/plain");
    intent.putExtra(Intent.EXTRA_SUBJECT, subject);
    intent.putExtra(Intent.EXTRA_TEXT, message);
    intent.putExtra(Intent.EXTRA_EMAIL, new String[] { REPORT_EMAIL });

    try {
      intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM,
          getFailAttachments(attachments));
      context.startActivity(intent);
    } catch (ActivityNotFoundException e) {
      Toast.makeText(context, R.string.could_not_find_email_application,
          Toast.LENGTH_LONG).show();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

Java Source Code List

• Back to Location/Application  ↑