Android Open Source - sana Image Provider






From Project

Back to project page sana.

License

The source code is released under:

Copyright (c) 2010, Moca All rights reserved. The source code for Moca is licensed under the BSD license as follows: Redistribution and use in source and binary forms, with or without modification, ...

If you think the Android project sana listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.

Java Source Code

package org.moca.db;
//from ww w .  ja v  a  2 s . c om
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

import org.moca.db.MocaDB.DatabaseHelper;
import org.moca.db.MocaDB.ImageSQLFormat;

import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteQueryBuilder;
import android.net.Uri;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
import android.text.TextUtils;
import android.util.Log;

public class ImageProvider extends ContentProvider {

    private static final String TAG = "ImageProvider";
    
    public static final String VIEW_PARAMETER = "view";
    public static final String THUMBNAIL_VIEW = "thumb";
    
    private static final String IMAGE_TABLE_NAME = "images";
    public static final String IMAGE_BUCKET_NAME = "/sdcard/dcim/moca/";
    
    private static final int IMAGES = 1;
    private static final int IMAGE_ID = 2;
    
    private DatabaseHelper mOpenHelper;
    private static final UriMatcher sUriMatcher;
    private static HashMap<String,String> sImageProjectionMap;
    
    @Override
    public boolean onCreate() {
        Log.i(TAG, "onCreate()");
        mOpenHelper = new DatabaseHelper(getContext());
        return true;
    }

  /**
   * Return a thumbnail Uri for a given ImageProvider item Uri. The returned
   * Uri will still be compatible with all ContentProvider methods and refers
   * to the same item that imageUri refers to.
   */
    public static Uri getThumbUri(Uri imageUri) {
      Uri.Builder thumbBuilder = imageUri.buildUpon();
      thumbBuilder.appendQueryParameter(VIEW_PARAMETER, THUMBNAIL_VIEW);
      return thumbBuilder.build();
    }
    
    private String basePath() {
      return "/data/data/org.moca/files/";
    }
    
    private String buildImageFilenameFromId(String imageId) {
      return basePath() + imageId;
    }
    
    private String buildThumbnailFilenameFromId(String imageId) {
      return basePath() + "thumb_" + imageId;
    }
    
    private String buildFilenameFromUri(Uri uri) {
      List<String> segments = uri.getPathSegments();
      
      // Invalid URI
      if (segments.size() != 2) 
        return "";
      
      String imageId = segments.get(1);
      String viewName = uri.getQueryParameter(VIEW_PARAMETER);
      
      if (THUMBNAIL_VIEW.equals(viewName)) {
        return buildThumbnailFilenameFromId(imageId);
      } else { // default to image view
        return buildImageFilenameFromId(imageId);
      }
    }
    
    private boolean deleteFile(String imageId) {
      String filename = buildImageFilenameFromId(imageId);
      File f = new File(filename);
      boolean result = f.delete();
      Log.i(TAG, "Deleting file for id " + imageId + " : " + filename + " " + (result ? "succeeded" : "failed"));
      filename = buildThumbnailFilenameFromId(imageId);
      f = new File(filename);
      boolean thumbResult = f.delete();
      Log.i(TAG, "Deleting thumbnail for id " + imageId + " : " + filename + " " + (thumbResult ? "succeeded" : "failed"));
      return result && thumbResult;
    }
    
    private boolean deleteFile(Uri uri) {
      List<String> segments = uri.getPathSegments();
      
      // Invalid URI
      if (segments.size() != 1) 
        return true;
      
      String imageId = segments.get(1);
      return deleteFile(imageId);
    }
    
    @Override
    public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
      String filename = buildFilenameFromUri(uri);
        Log.i(TAG, "openFile() for filename: " + filename + " mode: " + mode);
        File f = new File(filename); 
        
        //Hack to get image to write to database
        
        int m = ParcelFileDescriptor.MODE_READ_ONLY;
        if ("w".equals(mode)) {
          m = ParcelFileDescriptor.MODE_WRITE_ONLY | ParcelFileDescriptor.MODE_CREATE;
        } else if("rw".equals(mode) || "rwt".equals(mode)) {
          m = ParcelFileDescriptor.MODE_READ_WRITE;
        }
        return ParcelFileDescriptor.open(f,m);
    }
    
    
    
    
    @Override
    public Cursor query(Uri uri, String[] projection, String selection,
            String[] selectionArgs, String sortOrder) {
        Log.i(TAG, "query() uri="+uri.toString() + " projection=" + TextUtils.join(",",projection));
        
        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
        qb.setTables(IMAGE_TABLE_NAME);
        
        switch(sUriMatcher.match(uri)) {
        case IMAGES:    
            break;
        case IMAGE_ID:
            qb.appendWhere(ImageSQLFormat._ID + "=" + uri.getPathSegments().get(1));
            break;
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
        
        String orderBy;
        if(TextUtils.isEmpty(sortOrder)) {
            orderBy = ImageSQLFormat.DEFAULT_SORT_ORDER;
        } else {
            orderBy = sortOrder;
        }
        
        SQLiteDatabase db = mOpenHelper.getReadableDatabase();
        Cursor c = qb.query(db, projection, selection, selectionArgs, null, null, orderBy);
        c.setNotificationUri(getContext().getContentResolver(), uri);
        return c;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection,
            String[] selectionArgs) {
        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        int count = 0; 
        
        switch(sUriMatcher.match(uri)) {
        case IMAGES:
            count = db.update(IMAGE_TABLE_NAME, values, selection, selectionArgs);
            break;
            
        case IMAGE_ID:
            String procedureId = uri.getPathSegments().get(1);
            count = db.update(IMAGE_TABLE_NAME, values, ImageSQLFormat._ID + "=" + procedureId + (!TextUtils.isEmpty(selection) ? " AND (" + selection + ")" : ""), selectionArgs);
            break;
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
        
        getContext().getContentResolver().notifyChange(uri, null);
        return count;
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        int count;
        switch (sUriMatcher.match(uri)) {
        case IMAGES:
          LinkedList<String> idList = new LinkedList<String>();
          Cursor c = query(ImageSQLFormat.CONTENT_URI, new String[] { ImageSQLFormat._ID }, selection, selectionArgs, null);
          if(c.moveToFirst()) {
            while(!c.isAfterLast()) {
              String id = c.getString(c.getColumnIndex(ImageSQLFormat._ID));
              idList.add(id);
              c.moveToNext();
            }
          }
          c.deactivate();
          
            count = db.delete(IMAGE_TABLE_NAME, selection, selectionArgs);
            
            for(String id : idList) {
              deleteFile(id);
            }
            break;
        case IMAGE_ID:
            String imageId = uri.getPathSegments().get(1); 
            count = db.delete(IMAGE_TABLE_NAME, ImageSQLFormat._ID + "=" + imageId + (!TextUtils.isEmpty(selection) ? " AND (" + selection + ")" : ""), selectionArgs);
            deleteFile(uri);
            break;
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
        
        getContext().getContentResolver().notifyChange(uri, null);
        return count;
    }

    @Override
    public Uri insert(Uri uri, ContentValues initialValues) {
        if (sUriMatcher.match(uri) != IMAGES) {
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
        
        ContentValues values;
        if(initialValues != null) {
            values = new ContentValues(initialValues);
        } else {
            values = new ContentValues();
        }
        
        Long now = Long.valueOf(System.currentTimeMillis());
        
        if(values.containsKey(ImageSQLFormat.CREATED_DATE) == false) {
            values.put(ImageSQLFormat.CREATED_DATE, now);
        }
        
        if(values.containsKey(ImageSQLFormat.MODIFIED_DATE) == false) {
            values.put(ImageSQLFormat.MODIFIED_DATE, now);
        }
 
        if(values.containsKey(ImageSQLFormat.SAVED_PROCEDURE_ID) == false) {
            values.put(ImageSQLFormat.SAVED_PROCEDURE_ID, "");
        }
        
        if(values.containsKey(ImageSQLFormat.ELEMENT_ID) == false) {
            values.put(ImageSQLFormat.ELEMENT_ID, "");
        }
        
        if(values.containsKey(ImageSQLFormat.FILE_URI) == false) {
            values.put(ImageSQLFormat.FILE_URI, "");
        }
        
        if(values.containsKey(ImageSQLFormat.FILE_VALID) == false) {
            values.put(ImageSQLFormat.FILE_VALID, false);
        }
        
        if(values.containsKey(ImageSQLFormat.FILE_SIZE) == false) {
            values.put(ImageSQLFormat.FILE_SIZE, 0);
        }
        
        if(values.containsKey(ImageSQLFormat.UPLOAD_PROGRESS) == false) {
            values.put(ImageSQLFormat.UPLOAD_PROGRESS, 0);
        }
        
        if(values.containsKey(ImageSQLFormat.UPLOADED) == false) {
            values.put(ImageSQLFormat.UPLOADED, false);
        }
        
        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        long rowId = db.insert(IMAGE_TABLE_NAME, ImageSQLFormat.SAVED_PROCEDURE_ID, values);
        if(rowId > 0) {
            
            String filename = rowId + "";
            try {
                getContext().openFileOutput(filename, Context.MODE_PRIVATE).close();
            } catch (FileNotFoundException e) {
                Log.e(TAG, "Couldn't make the file: " + e);
            } catch (IOException e) {
                Log.e(TAG, "Couldn't make the file: " + e);
            }
            String path = getContext().getFileStreamPath(filename).getAbsolutePath();
            Log.i(TAG, "File path is : " + path);
            Uri noteUri = ContentUris.withAppendedId(ImageSQLFormat.CONTENT_URI, rowId);
            getContext().getContentResolver().notifyChange(noteUri, null);
            return noteUri;
        }
        
        throw new SQLException("Failed to insert row into " + uri);
    }

    @Override
    public String getType(Uri uri) {
        Log.i(TAG, "getType(uri="+uri.toString()+")");
        switch(sUriMatcher.match(uri)) {
        case IMAGES:
            return ImageSQLFormat.CONTENT_TYPE;
        case IMAGE_ID:
            return ImageSQLFormat.CONTENT_ITEM_TYPE;
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
    }
    
    public static void onCreateDatabase(SQLiteDatabase db) {
        Log.i(TAG, "Creating Image Table");
        db.execSQL("CREATE TABLE " + IMAGE_TABLE_NAME + " ("
                + ImageSQLFormat._ID + " INTEGER PRIMARY KEY,"
                + ImageSQLFormat.SAVED_PROCEDURE_ID + " TEXT,"
                + ImageSQLFormat.ELEMENT_ID + " TEXT,"
                + ImageSQLFormat.FILE_URI + " TEXT,"
                + ImageSQLFormat.FILE_VALID + " INTEGER,"
                + ImageSQLFormat.FILE_SIZE + " INTEGER,"
                + ImageSQLFormat.UPLOAD_PROGRESS + " INTEGER,"
                + ImageSQLFormat.UPLOADED + " INTEGER,"
                + ImageSQLFormat.CREATED_DATE + " INTEGER,"
                + ImageSQLFormat.MODIFIED_DATE + " INTEGER"
                + ");");
    }
    
    public static void onUpgradeDatabase(SQLiteDatabase db, int oldVersion, int newVersion) {
        Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
                + newVersion);
        if (oldVersion == 1 && newVersion == 2) {
          // Do nothing
        }
    }

    
    static {
        sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        sUriMatcher.addURI(MocaDB.IMAGE_AUTHORITY, "images", IMAGES);
        sUriMatcher.addURI(MocaDB.IMAGE_AUTHORITY, "images/#", IMAGE_ID);
        
        sImageProjectionMap = new HashMap<String, String>();
        sImageProjectionMap.put(ImageSQLFormat._ID, ImageSQLFormat._ID);
        sImageProjectionMap.put(ImageSQLFormat.SAVED_PROCEDURE_ID, ImageSQLFormat.SAVED_PROCEDURE_ID);
        sImageProjectionMap.put(ImageSQLFormat.ELEMENT_ID, ImageSQLFormat.ELEMENT_ID);
        sImageProjectionMap.put(ImageSQLFormat.FILE_URI, ImageSQLFormat.FILE_URI);
        sImageProjectionMap.put(ImageSQLFormat.FILE_VALID, ImageSQLFormat.FILE_VALID);
        sImageProjectionMap.put(ImageSQLFormat.FILE_SIZE, ImageSQLFormat.FILE_SIZE);
        sImageProjectionMap.put(ImageSQLFormat.UPLOAD_PROGRESS, ImageSQLFormat.UPLOAD_PROGRESS);
        sImageProjectionMap.put(ImageSQLFormat.UPLOADED, ImageSQLFormat.UPLOADED);
        sImageProjectionMap.put(ImageSQLFormat.CREATED_DATE, ImageSQLFormat.CREATED_DATE);
        sImageProjectionMap.put(ImageSQLFormat.MODIFIED_DATE, ImageSQLFormat.MODIFIED_DATE);
    }
    
}




Java Source Code List

.Moca.java
org.moca.Constants.java
org.moca.ImagePreviewDialog.java
org.moca.ScalingImageAdapter.java
org.moca.SelectableImageView.java
org.moca.activity.NotificationList.java
org.moca.activity.NotificationViewer.java
org.moca.activity.PatientInfoDialog.java
org.moca.activity.ProcedureRunner.java
org.moca.activity.ProceduresList.java
org.moca.activity.SavedProcedureList.java
org.moca.activity.Settings.java
org.moca.db.EncounterDAO.java
org.moca.db.EventDAO.java
org.moca.db.EventProvider.java
org.moca.db.Event.java
org.moca.db.ImageProvider.java
org.moca.db.MocaDB.java
org.moca.db.NotificationMessage.java
org.moca.db.NotificationProvider.java
org.moca.db.PatientInfo.java
org.moca.db.PatientProvider.java
org.moca.db.PatientValidator.java
org.moca.db.ProcedureDAO.java
org.moca.db.ProcedureProvider.java
org.moca.db.SavedProcedureProvider.java
org.moca.db.SoundProvider.java
org.moca.media.AudioPlayer.java
org.moca.net.MDSCode.java
org.moca.net.MDSInterface.java
org.moca.net.MDSNotification.java
org.moca.net.MDSResult.java
org.moca.net.SMSReceive.java
org.moca.procedure.BinaryUploadElement.java
org.moca.procedure.DateElement.java
org.moca.procedure.GpsElement.java
org.moca.procedure.MultiSelectElement.java
org.moca.procedure.PatientIdElement.java
org.moca.procedure.PictureElement.java
org.moca.procedure.ProcedureElement.java
org.moca.procedure.ProcedurePage.java
org.moca.procedure.ProcedureParseException.java
org.moca.procedure.Procedure.java
org.moca.procedure.RadioElement.java
org.moca.procedure.SelectElement.java
org.moca.procedure.SoundElement.java
org.moca.procedure.TextElement.java
org.moca.procedure.TextEntryElement.java
org.moca.procedure.ValidationError.java
org.moca.procedure.branching.Criteria.java
org.moca.procedure.branching.Criterion.java
org.moca.procedure.branching.LogicAnd.java
org.moca.procedure.branching.LogicBase.java
org.moca.procedure.branching.LogicNot.java
org.moca.procedure.branching.LogicOr.java
org.moca.service.BackgroundUploader.java
org.moca.service.QueueManager.java
org.moca.service.ServiceConnector.java
org.moca.service.ServiceListener.java
org.moca.task.CheckCredentialsTask.java
org.moca.task.ImageProcessingTaskRequest.java
org.moca.task.ImageProcessingTask.java
org.moca.task.MDSSyncTask.java
org.moca.task.PatientLookupListener.java
org.moca.task.PatientLookupTask.java
org.moca.task.ResetDatabaseTask.java
org.moca.task.ValidationListener.java
org.moca.util.MocaUtil.java
org.moca.util.UserDatabase.java