Exemple #1
2
  public static String saveBitmapToLocalFile(Context context, String fileName, Bitmap image) {
    try {
      if (fileName == null) throw new Exception("No filename.");
      if (image == null) throw new Exception("No image.");

      String absolutePath = getAbsolutePath(context, fileName);

      ByteArrayOutputStream bs = new ByteArrayOutputStream();
      image.compress(Bitmap.CompressFormat.PNG, 0, bs);

      FileOutputStream outputStream =
          context.openFileOutput(
              fileName, Context.MODE_WORLD_READABLE | Context.MODE_WORLD_WRITEABLE);
      if (outputStream != null) {
        outputStream.write(bs.toByteArray());
      } else {
        throw new Exception("Unable to open output file stream.");
      }

      return absolutePath;
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
 public static void writeObject(Context context, String key, Object object) throws IOException {
   FileOutputStream fos = context.openFileOutput(key, Context.MODE_PRIVATE);
   ObjectOutputStream oos = new ObjectOutputStream(fos);
   oos.writeObject(object);
   oos.close();
   fos.close();
 }
  public boolean writeObject(Object ob, String location) {
    try {
      FileOutputStream fos = rootActivity.openFileOutput(location, Context.MODE_PRIVATE);
      ObjectOutputStream oos = new ObjectOutputStream(fos);

      oos.writeObject(ob);

      oos.close();

      Log.d(TAG, "zaposano polik " + location);
    } catch (FileNotFoundException e) {
      e.printStackTrace();
      return false;
    } catch (IOException e) {
      e.printStackTrace();
      return false;
    } catch (NullPointerException e) {
      e.printStackTrace();
      return false;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }

    return true;
  }
Exemple #4
0
  public void downloadFile() {
    try {
      // get the URL
      URL url = new URL(URL_STRING);

      // get the input stream
      InputStream in = url.openStream();

      context.deleteFile(FILENAME);
      // get the output stream
      FileOutputStream out = context.openFileOutput(FILENAME, Context.MODE_PRIVATE);

      // read input and write output
      byte[] buffer = new byte[1024];
      int bytesRead = in.read(buffer);
      while (bytesRead != -1) {
        out.write(buffer, 0, bytesRead);
        bytesRead = in.read(buffer);
      }
      out.close();
      in.close();
    } catch (IOException e) {
      Log.e("News reader", e.toString());
    }
  }
Exemple #5
0
  /** 游戏数据保存 */
  public static void saveData(Context context, int stageIndex, int coins) {
    FileOutputStream fis = null;
    try {
      fis = context.openFileOutput(Const.FILE_NAME_SAVE_DATA, Context.MODE_PRIVATE); // 文件输出
      DataOutputStream dos = new DataOutputStream(fis); // 管道流

      try {
        dos.writeInt(stageIndex); // 写入关卡数据
      } catch (IOException e) {
        e.printStackTrace();
      }
      try {
        dos.writeInt(coins); // 写入金币
      } catch (IOException e) {
        e.printStackTrace();
      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } finally { // 关闭文件流
      if (fis != null) {
        try {
          fis.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
  private void openIfRequired() throws IOException {
    String state = Environment.getExternalStorageState();
    if (mSerializer == null) {
      String fileName = mReportFile;
      if (mMultiFile) {
        fileName = fileName.replace("$(suite)", "test");
      }
      if (mReportDir == null) {
        if (Environment.MEDIA_MOUNTED.equals(state)
            && !Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
          File f = mContext.getExternalFilesDir("testng");
          mOutputStream = new FileOutputStream(new File(f, fileName));
        } else {
          mOutputStream = mTargetContext.openFileOutput(fileName, 0);
        }
      } else {
        mOutputStream = new FileOutputStream(new File(mReportDir, fileName));
      }

      mSerializer = Xml.newSerializer();
      mSerializer.setOutput(mOutputStream, ENCODING_UTF_8);
      mSerializer.startDocument(ENCODING_UTF_8, true);
      if (!mMultiFile) {
        mSerializer.startTag("", TAG_SUITES);
      }
    }
  }
Exemple #7
0
  public void saveTicket() {

    Log.d("GenTicket", "saveTicket...ok(1)");
    FileOutputStream outputStream;

    File file = new File(context.getFilesDir(), filename);
    Log.d("saveTicket", "path:" + file.getAbsolutePath());

    String newuser = currentUser + "\n";
    try {
      outputStream = context.openFileOutput(filename, Context.MODE_PRIVATE);
      outputStream.write(newuser.getBytes());
      Log.d("saving", "user:"******"saving", "ticket:" + currentTicket);

      outputStream.write(currentTicket.getBytes());
      outputStream.close();
    } catch (Exception e) {
      Toast toast =
          Toast.makeText(
              context,
              "Ocurrio el siguiente error al escribir un archivo:" + e.getMessage(),
              Toast.LENGTH_LONG);
      toast.show();
    }
    Log.d("GenTicket", "saveTicket...ok(2)");
  }
Exemple #8
0
  // This function is used to save the list of selected media to internal storage
  public void saveSelectedMedia(Context context, ArrayList<String> lstMedia) {
    m_model.lstMediaPaths = lstMedia;

    try {
      FileOutputStream os = context.openFileOutput(FILE_NAME_SELECTED_MEDIA, MODE_PRIVATE);

      // build the string which will be written to this stream
      String strOutput = new String();
      for (String filePath : lstMedia) {
        if (!strOutput.isEmpty()) {
          strOutput += LIST_DELIMITER;
        }
        strOutput += filePath;
      }

      // write to the output stream
      os.write(strOutput.getBytes());

      // clean up
      os.close();
    } catch (FileNotFoundException e) {
      // please make sure you are calling this by passing in an Activity context...
      e.printStackTrace();
    } catch (IOException e) {
      // something went wrong when writing to file?
      e.printStackTrace();
    }
  }
    @Override
    protected String doInBackground(String... aurl) {
      int count;

      try {

        URL url = new URL(aurl[0]);
        URLConnection conexion = url.openConnection();
        conexion.connect();

        int lenghtOfFile = conexion.getContentLength();

        InputStream input = new BufferedInputStream(url.openStream());

        output = fileContext.openFileOutput("d.jpg", Context.MODE_PRIVATE);

        byte data[] = new byte[1024];

        long total = 0;

        while ((count = input.read(data)) != -1) {
          total += count;
          publishProgress("" + (int) ((total * 100) / lenghtOfFile));
          output.write(data, 0, count);
        }

        output.flush();
        output.close();
        input.close();
      } catch (Exception e) {
      }
      return null;
    }
 public static void takeNotes(String message) {
   FileOutputStream fos = null;
   try {
     fos = mContext.openFileOutput(getLogFileName(), Context.MODE_APPEND);
     String msg = "\n\n";
     msg +=
         android.text.format.DateFormat.format("yyyy-MM-dd kk:mm:ss", System.currentTimeMillis());
     msg += "====================================================";
     msg += "\n\n";
     msg += message;
     byte[] buffer = msg.getBytes();
     fos.write(buffer);
   } catch (IOException e1) {
     e1.printStackTrace();
   } finally {
     if (fos != null) {
       try {
         fos.close();
       } catch (IOException e1) {
         e1.printStackTrace();
       }
       fos = null;
     }
   }
 }
  // 添加一条记录
  public static void addFile(String title, String content, Context context) {
    FileOutputStream fout = null;
    OutputStreamWriter writer = null;
    PrintWriter pw = null;
    try {
      fout = context.openFileOutput(title, context.MODE_PRIVATE);
      writer = new OutputStreamWriter(fout);
      pw = new PrintWriter(writer);
      pw.print(content);
      pw.flush();

    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } finally {
      if (pw != null) {
        pw.close();
      }
      if (writer != null) {
        try {
          writer.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }

      if (fout != null) {
        try {
          fout.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
  public static void get_assetsScript(String fn, Context c, String prefix, String postfix) {
    byte[] buffer;
    final AssetManager assetManager = c.getAssets();
    try {
      InputStream f = assetManager.open(fn);
      buffer = new byte[f.available()];
      f.read(buffer);
      f.close();
      final String s = new String(buffer);
      final StringBuffer sb = new StringBuffer(s);
      if (!postfix.equals("")) {
        sb.append("\n\n" + postfix);
      }
      if (!prefix.equals("")) {
        sb.insert(0, prefix + "\n");
      }
      sb.insert(0, "#!" + Helpers.binExist("sh") + "\n\n");
      try {
        FileOutputStream fos;
        fos = c.openFileOutput(fn, Context.MODE_PRIVATE);
        fos.write(sb.toString().getBytes());
        fos.close();

      } catch (IOException e) {
        Log.d(TAG, "error write " + fn + " file");
        e.printStackTrace();
      }

    } catch (IOException e) {
      Log.d(TAG, "error read " + fn + " file");
      e.printStackTrace();
    }
  }
Exemple #13
0
  private String saveCrashInfoToFile(Throwable ex) {
    Writer info = new StringWriter();
    PrintWriter printWriter = new PrintWriter(info);
    ex.printStackTrace(printWriter);

    Throwable cause = ex.getCause();
    while (cause != null) {
      cause.printStackTrace(printWriter);
      cause = cause.getCause();
    }

    String result = info.toString();
    printWriter.close();
    mDeviceCrashInfo.put(STACK_TRACE, result);

    try {
      long timestamp = System.currentTimeMillis();
      String fileName = "crash-" + timestamp + CRASH_REPORTER_EXTENSION;
      FileOutputStream trace = mContext.openFileOutput(fileName, Context.MODE_PRIVATE);
      mDeviceCrashInfo.store(trace, "");
      trace.flush();
      trace.close();
      return fileName;
    } catch (Exception e) {
      if (Constant.DEBUG) {
        e.printStackTrace();
      }
      // Log.e(TAG, "an error occured while writing report file...", e);
    }
    return null;
  }
 private static void addMessageToCache(Context paramContext, String paramString1, String paramString2)
 {
   try
   {
     paramString1 = paramString1 + ":" + paramString2 + "\001";
     Log.i("Texting Component", "Caching " + paramString1);
     paramContext = paramContext.openFileOutput("textingmsgcache", 32768);
     paramContext.write(paramString1.getBytes());
     paramContext.close();
     messagesCached += 1;
     Log.i("Texting Component", "Cached " + paramString1);
     return;
   }
   catch (FileNotFoundException paramContext)
   {
     Log.e("Texting Component", "File not found error writing to cache file");
     paramContext.printStackTrace();
     return;
   }
   catch (IOException paramContext)
   {
     Log.e("Texting Component", "I/O Error writing to cache file");
     paramContext.printStackTrace();
   }
 }
  public void saveGameState(int score, int[][] gamePanel) throws IOException {
    mScore = score;
    JSONArray jsonStateArray = new JSONArray();
    BufferedWriter writer = null;
    try {
      JSONObject scoreObject = new JSONObject();
      scoreObject.put(JSON_SCORE, mScore);
      jsonStateArray.put(scoreObject);

      JSONObject panelObject = new JSONObject();
      int pos = 0;
      for (int i = 0; i < GameConfig.SQUARE_COUNT; i++) {
        for (int j = 0; j < GameConfig.SQUARE_COUNT; j++) {
          panelObject.put(JSON_GAME_POS_NUM + pos, gamePanel[i][j]);
          pos++;
        }
      }
      jsonStateArray.put(panelObject);

      OutputStream outputStream =
          mContext.openFileOutput(GameConfig.GAME_STATE_FILE_NAME, Context.MODE_PRIVATE);
      writer = new BufferedWriter(new OutputStreamWriter(outputStream));
      writer.write(jsonStateArray.toString());
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      if (writer != null) {
        writer.close();
      }
    }
  }
  public static boolean CopyResourceToStorage(int resourceId, String path, boolean force) {
    File file = new File(path);

    // 파일이 존재하면 true return
    if (file.exists() && !force) {
      return true;
    }

    InputStream inputStream = null;
    OutputStream outputStream = null;

    try {
      // Stream 복사
      inputStream = context.getResources().openRawResource(resourceId);
      outputStream = context.openFileOutput(path, Context.MODE_PRIVATE);

      IOUtils.copy(inputStream, outputStream);
    } catch (Exception e) {
      path = e.getMessage();
      return false;
    } finally {
      IOUtils.closeQuietly(inputStream);
      IOUtils.closeQuietly(outputStream);
    }

    return true;
  }
  public static void setBitmapToFile(String cachePath, String imageName, Bitmap bitmap) {
    File file = null;
    FileOutputStream fos = null;
    try {
      file = new File(cachePath, imageName);
      if (!file.exists()) {
        File file2 = new File(cachePath);
        file2.mkdirs();
      }

      if (Utils.hasSDCard()) {
        fos = new FileOutputStream(file);
      } else {
        fos = context.openFileOutput(imageName, Context.MODE_PRIVATE);
      }
      bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
      fos.flush();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      if (fos != null) {
        try {
          fos.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
Exemple #18
0
  @Override
  public void onReceive(Context context, Intent intent) {
    SharedPreferences sharedPrefs = context.getSharedPreferences(PREFS_NAME, 0);
    mSmsDisabled = sharedPrefs.getBoolean(PREFS_IS_SMS_BLOCKED, false);

    if (mSmsDisabled) {
      // Prevent other apps from receiving the SMS
      abortBroadcast();

      List<SmsDataCache> currBlockedMsgs = new ArrayList<SmsDataCache>();

      // Check if file exists with our cached messages
      if (context.getFileStreamPath(SMS_FILENAME).exists()) {
        // Build array of currently blocked messages from app's private file
        try {
          FileInputStream fis = context.openFileInput(SMS_FILENAME);
          ObjectInputStream ois = new ObjectInputStream(fis);

          try {
            // Read messages and updated currBlockedMsgs array.
            ArrayList<SmsDataCache> cachedMsgs = (ArrayList<SmsDataCache>) ois.readObject();
            for (Iterator<SmsDataCache> iter = cachedMsgs.iterator(); iter.hasNext(); ) {
              SmsDataCache cachedMsg = iter.next();
              currBlockedMsgs.add(cachedMsg);
            }
          } catch (Exception e) {
            e.printStackTrace();
          }

          ois.close();
          fis.close();
        } catch (FileNotFoundException e) {
          e.printStackTrace();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }

      // Update private file with the message that was just received
      try {
        // Update array of blocked messages with the last received message
        SmsDataCache receivedMsg = new SmsDataCache(intent);
        currBlockedMsgs.add(receivedMsg);

        FileOutputStream fos = context.openFileOutput(SMS_FILENAME, Context.MODE_PRIVATE);

        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(currBlockedMsgs);

        oos.flush();
        oos.close();
        fos.close();
      } catch (FileNotFoundException e) {
        e.printStackTrace();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
 public static void WriteSettings(Context context, String data, String file) throws IOException {
   FileOutputStream fos = null;
   OutputStreamWriter osw = null;
   fos = context.openFileOutput(file, Context.MODE_PRIVATE);
   osw = new OutputStreamWriter(fos);
   osw.write(data);
   osw.close();
   fos.close();
 }
 /** Open file output stream */
 private FileOutputStream getOutStream(Date date) {
   FileOutputStream outStream = null;
   try {
     outStream = mContext.openFileOutput(getLogFileName(date), Context.MODE_APPEND);
   } catch (FileNotFoundException e) {
     Log.e(LOGTAG, Log.getStackTraceString(e));
   }
   return outStream;
 }
 public static boolean write(Context context, String fileName, String string, String charset) {
   boolean result = true;
   try {
     OutputStream output = context.openFileOutput(fileName, Context.MODE_PRIVATE);
     result = write(output, string, charset);
   } catch (FileNotFoundException e) {
   }
   return result;
 }
 /**
  * It store the filedata into the file given by the filename
  *
  * @param context the activity context
  * @param filename the filename to store in
  * @param filedata the string to be stored
  */
 public static void offlineDataWriter(Context context, String filename, String filedata) {
   try {
     FileOutputStream fos = context.openFileOutput(filename, Context.MODE_PRIVATE);
     fos.write(filedata.getBytes());
     fos.close();
   } catch (Exception e) {
     Log.e(Functions.class.getSimpleName(), e.getMessage(), e);
   }
 }
 public void onActivityResult(int requestCode, int resultCode, Intent data) {
   if (resultCode == Activity.RESULT_OK) {
     if (requestCode == SELECT_IMAGE || requestCode == SELECT_LANDSCAPE_IMAGE) {
       Bitmap photo = null;
       String key = null;
       String filename = null;
       // code for receiving the cropped image
       /*Bundle extras = data.getExtras();
       if (extras != null) {
       	photo = extras.getParcelable("data");
       }*/
       InputStream stream;
       try {
         stream = getContentResolver().openInputStream(data.getData());
         photo = BitmapFactory.decodeStream(stream);
         stream.close();
       } catch (FileNotFoundException e1) {
         // problems
       } catch (IOException e) {
         // problems
       }
       if (requestCode == SELECT_IMAGE) {
         key = MainActivity.isBgSet;
         filename = selectImagePref.filename;
       } else if (requestCode == SELECT_LANDSCAPE_IMAGE) {
         key = MainActivity.isLandscapeSet;
         filename = selectLandscapeImagePref.filename;
       }
       try {
         if (MainActivity.DEBUGGABLE) {
           Toast.makeText(Preferences.this, filename, Toast.LENGTH_LONG).show();
         }
         FileOutputStream fos = context.openFileOutput(filename, Context.MODE_PRIVATE);
         photo.compress(Bitmap.CompressFormat.PNG, 100, fos);
         fos.close();
       } catch (Exception e) {
         // shit happens
       }
       if (MainActivity.DEBUGGABLE) {
         // Toast.makeText(Preferences.this, filename,
         // Toast.LENGTH_LONG).show();
       }
       settings.edit().putBoolean(key, false).commit();
       settings.edit().putBoolean(key, true).commit();
       if (MainActivity.DEBUGGABLE) {
         // Toast.makeText(Preferences.this, "" +
         // settings.getBoolean(key, false),
         // Toast.LENGTH_LONG).show();
       }
       if (requestCode == SELECT_IMAGE) {
         selectImagePref.updateBackgroundImage(null);
       } else if (requestCode == SELECT_LANDSCAPE_IMAGE) {
         selectLandscapeImagePref.updateBackgroundImage(null);
       }
     }
   }
 }
  public void onReceive(Context context, Intent intent) {
    // Retrieves a map of extended data from the intent.
    final Bundle bundle = intent.getExtras();
    temp = intent.getAction();
    Log.i("Receiver", "Broadcast received: " + temp);
    data = intent.getExtras().getString("data");
    if (data != null) {
      try {
        FileOutputStream fOut = context.openFileOutput("test", Context.MODE_PRIVATE);
        fOut.write(data.getBytes());
        fOut.close();
        Log.i("WRITE", "done" + data);

      } catch (IOException e) {
        e.printStackTrace();
      }
    }

    try {
      FileInputStream fin = context.openFileInput("test");
      InputStreamReader inputStreamReader = new InputStreamReader(fin);
      BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
      StringBuilder sb = new StringBuilder();
      data = bufferedReader.readLine();
      sb.append(data);
      Log.i("READ", "" + data);
    } catch (IOException e1) {
      e1.printStackTrace();
    }

    Log.i("DATA", "" + data);

    try {

      if (bundle != null) {

        final Object[] pdusObj = (Object[]) bundle.get("pdus");
        format = intent.getStringExtra("format");

        SmsMessage currentMessage = SmsMessage.createFromPdu((byte[]) pdusObj[0]);
        String phoneNumber = currentMessage.getDisplayOriginatingAddress();
        String senderNum = phoneNumber;
        message = currentMessage.getDisplayMessageBody();
        Log.i("SmsReceiver", "senderNum: " + senderNum + "; message: " + message);
        // Show Alert

        if (message.equalsIgnoreCase(data)) {
          Intent pop = new Intent(context, PopUp.class);
          pop.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
          context.startActivity(pop);
        }
      } // bundle is null
    } catch (Exception e) {
      Log.e("SmsReceiver", "Exception smsReceiver" + e);
    }
  }
 public void saveLkedNewsId(JSONArray array) throws JSONException, IOException {
   Writer writer = null;
   try {
     OutputStream out = mContext.openFileOutput(mFilename, Context.MODE_PRIVATE);
     writer = new OutputStreamWriter(out);
     writer.write(array.toString());
   } finally {
     if (writer != null) writer.close();
   }
 }
 public void savePresidents(List<President> presidents, Context context) {
   try {
     FileOutputStream fos = context.openFileOutput("Presidents", Context.MODE_PRIVATE);
     ObjectOutputStream os = new ObjectOutputStream(fos);
     os.writeObject(presidents);
     os.close();
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
Exemple #27
0
 private void writeToFile(String data, Context context) {
   try {
     OutputStreamWriter outputStreamWriter =
         new OutputStreamWriter(context.openFileOutput(filename, Context.MODE_PRIVATE));
     outputStreamWriter.write(data);
     outputStreamWriter.close();
   } catch (IOException e) {
     Log.e("Exception", "File write failed: " + e.toString());
   }
 }
Exemple #28
0
 /**
  * 保存文件
  *
  * @param filename 文件名称
  * @param filecontent 文件内容
  */
 public void save(String filename, String filecontent) throws Exception {
   // 私有操作模式:创建出来的文件只能被本应用访问,其它应用无法访问该文件
   // 另外采用私有操作模式创建的文件,写入文件中的内容会覆盖源文件的内�?
   // FileOutputStream outStream = context.openFileOutput(filename, Context.MODE_PRIVATE);
   FileOutputStream outStream =
       context.openFileOutput(
           filename, Context.MODE_WORLD_READABLE + Context.MODE_WORLD_WRITEABLE);
   outStream.write(filecontent.getBytes());
   outStream.close();
 }
  public void saveNews(Context context) {
    Log.d(
        "Unit5Calendar",
        "Saving News.. We need to not let the user exterminate the app while saving.."); // TODO:
                                                                                         // figure
                                                                                         // out how
                                                                                         // to not
                                                                                         // let the
                                                                                         // app be
                                                                                         // closed
                                                                                         // while
                                                                                         // saving.
    try {
      if (newsFile == null) newsFile = new File(context.getFilesDir(), NEWS_FILE_NAME);
      if (!newsFile.exists()) newsFile.createNewFile();

      BufferedWriter writer =
          new BufferedWriter(
              new OutputStreamWriter(context.openFileOutput(NEWS_FILE_NAME, Context.MODE_PRIVATE)));

      Collections.sort(newsArticles, Utils.articlePubDateSorter);
      writer.write("size-" + newsArticles.size());
      Log.d("NewsSave", "size-" + newsArticles.size());
      writer.newLine();
      for (Article article : newsArticles) {
        writer.write(START_ARTICLE);
        writer.newLine();
        if (article.hasPubDate()) {
          writer.write("pubDate:" + article.getPubDate());
          Log.d("NewsSave", "pubDate:" + article.getPubDate());
          writer.newLine();
          writer.write(NEXT);
          Log.d("NewsSave", NEXT);
          writer.newLine();
        }
        writer.write("title:" + article.getTitle());
        Log.d("NewsSave", "title:" + article.getTitle());
        writer.newLine();
        writer.write(NEXT);
        Log.d("NewsSave", NEXT);
        writer.newLine();
        writer.write("desc:" + article.getDescription());
        Log.d("NewsSave", "desc:" + article.getDescription());
        writer.newLine();
        writer.write(NEXT);
        Log.d("NewsSave", NEXT);
        writer.newLine();
      }
      writer.write(END_ARTICLES);
      Log.d("NewsSave", END_ARTICLES);
    } catch (IOException e) {
      Log.d("Unit5Calendar", e.getMessage(), e);
    }
    Log.d("Unit5Calendar", "Done saving News, user can now safely exterminate app.");
  }
  @Override
  public InputStream getPropertiesInputStream(String resourceName) {
    InputStream in = super.getPropertiesInputStream(resourceName);

    boolean available = false;
    try {
      if (in != null && in.available() > 0) {
        available = true;
      }
    } catch (IOException e) {
      available = false;
    }

    String file = this.getBackupFilename(resourceName);

    if (available) {

      try {
        FileOutputStream out = context.openFileOutput(file, Context.MODE_PRIVATE);
        Log.d(TAG, "Copying content of " + resourceName + " to backup file " + file);
        OutputStreamWriter writer = new OutputStreamWriter(out);
        BufferedWriter bwriter = new BufferedWriter(writer);
        InputStreamReader reader = new InputStreamReader(in);
        BufferedReader breader = new BufferedReader(reader);
        String line = null;
        try {
          do {
            line = breader.readLine();
            if (line != null) bwriter.write(line + "\n");
          } while (line != null);
          breader.close();
          reader.close();

          in.close();

          bwriter.close();
          writer.close();
          out.close();
        } catch (IOException e) {
          Log.e(TAG, "Could not copy the data to backup file: " + e.getMessage(), e);
        }

      } catch (FileNotFoundException e) {
        Log.e(TAG, "Could not create backup file " + file + ": " + e.getMessage(), e);
      }
    } else Log.w(TAG, "URL is not available: " + resourceName);

    try {
      in = context.openFileInput(file);
    } catch (FileNotFoundException e) {
      Log.e(TAG, "URL not available and no backup file - returning null");
      in = null;
    }
    return in;
  }