Java Sqlite数据库-如何将从camera intent拍摄的图像以及hashmap保存到Sqlite以便以后检索？

我的应用程序有着无尽的问题，我正在忙着制作一个应用程序，用户可以从地图上点击的点拍照，然后返回图像，所有这些都可以100%正常工作，但问题是，当用户退出应用程序或导航到不同的活动时，所有标记都消失了。所以我在这里问了一个问题，如何保存标记和地图，有些人说使用

SharedReferences

和其他SQLite数据库

现在，我已经实现了这两种方法，但没有一种方法可以实现我想要实现的目标，那就是将图像保存到特定的标记，并在用户退出应用程序并返回后，当用户点击标记时返回该图像

这是我的SQlite代码：

这是我的位置db.java

public class LocationsDB extends SQLiteOpenHelper {

    /**
     * Database name
     */
    private static String DBNAME = "locationmarkersqlite";
    private static int VERSION = 1;
    public static final String FIELD_ROW_ID = "_id";
    public static final String FIELD_LAT = "lat";
    public static final String FIELD_LNG = "lng";
    public static final String FIELD_ZOOM = "zom";
    public static final String FIELD_IMAGE = "img";
    public static final String FIELD_HASH = "hash";
    private static final String DATABASE_TABLE = "locations";

    private SQLiteDatabase mDB;

    public LocationsDB(Context context) {
        super(context, DBNAME, null, VERSION);
        this.mDB = getWritableDatabase();
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        String sql = "create table " + DATABASE_TABLE + " ( " +
                FIELD_ROW_ID + " integer primary key autoincrement , " +
                FIELD_LNG + " double , " +
                FIELD_LAT + " double , " +
                FIELD_ZOOM + " text , " +
                FIELD_IMAGE + " image , " +
                FIELD_HASH + "text " +
                " ) ";

        db.execSQL(sql);
    }

    public long insert(ContentValues contentValues) {
        long rowID = mDB.insert(DATABASE_TABLE, null, contentValues);
        return rowID;
    }

    public int del() {
        int cnt = mDB.delete(DATABASE_TABLE, null, null);
        return cnt;
    }

    public Cursor getAllLocations() {
        return mDB.query(DATABASE_TABLE, new String[]{FIELD_ROW_ID, FIELD_LAT, FIELD_LNG, FIELD_ZOOM, FIELD_IMAGE, FIELD_HASH}, null, null, null, null, null, null);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }
}

这是MyLocationContentProvider.java

public class LocationsContentProvider extends ContentProvider {

    public static final String PROVIDER_NAME = "com.example.mainapp.locations";
    public static final Uri CONTENT_URI = Uri.parse("content://" + PROVIDER_NAME + "/locations");
    private static final int LOCATIONS = 1;
    private static final UriMatcher uriMatcher;

    static {
        uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        uriMatcher.addURI(PROVIDER_NAME, "locations", LOCATIONS);
    }

    LocationsDB mLocationsDB;

    @Override
    public boolean onCreate() {
        mLocationsDB = new LocationsDB(getContext());
        return true;
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        long rowID = mLocationsDB.insert(values);
        Uri _uri = null;
        if (rowID > 0) {
            _uri = ContentUris.withAppendedId(CONTENT_URI, rowID);
        } else {
            try {
                throw new SQLException("Failed to insert : " + uri);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return _uri;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection,
                      String[] selectionArgs) {
        return 0;
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int cnt = 0;
        cnt = mLocationsDB.del();
        return cnt;
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {

        if (uriMatcher.match(uri) == LOCATIONS) {
            return mLocationsDB.getAllLocations();
        }
        return null;
    }

    @Override
    public String getType(Uri uri) {
        return null;
    }
}

然后在我的主要活动图活动中，我有以下内容：

private GoogleMap googleMap;
private static final String EXTRA_PLACE = "thePoint";
private static final int TAKE_PICTURE = 0;
LatLng thePoint;
Bitmap bitmap;
final Context context = this;
protected Dialog view;
private Uri fileUri;
private int rotate;
private File image;
private Map<String, Bitmap> myMarkersHash;
private String timeStamp;
private String markerId;
byte[] imageData;
ByteArrayOutputStream baos;
ImageView markerIcon;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.fragment_googlemaps);

    myMarkersHash = new HashMap<String, Bitmap>();


    setUpMap();

    plotMarkers(mMyMarkersArray);

}

private void plotMarkers(ArrayList<MyMarker> markers) {
    if (markers.size() > 0) {
        for (MyMarker myMarker : markers) {
            MarkerOptions markerOption = new MarkerOptions().position(new LatLng(myMarker.getmLatitude(), myMarker.getmLongitude()));
            markerOption.icon(BitmapDescriptorFactory.fromResource(R.drawable.ict_icon));

            Marker currentMarker = googleMap.addMarker(markerOption);
            mMarkersHashMap.put(currentMarker, myMarker);

            CameraPosition cameraPosition = new CameraPosition.Builder().target(
                    new LatLng(xx.xx, xx.xx)).zoom(9).bearing(0).tilt(80).build();


            googleMap.setOnMapLongClickListener(this);
            googleMap.setOnMarkerClickListener(this);
            googleMap.setOnMapClickListener(this);
            googleMap.setOnInfoWindowClickListener(this);
            googleMap.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
            googleMap.setMyLocationEnabled(true);
            googleMap.getUiSettings().setCompassEnabled(true);
            googleMap.getUiSettings().setMyLocationButtonEnabled(true);
            googleMap.setInfoWindowAdapter(new MarkerInfoWindowAdapter());
            getSupportLoaderManager().initLoader(0, null, this);


        }
    }
}


private void setUpMap() {
    if (googleMap == null) {
        googleMap = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map)).getMap();

        if (googleMap != null) {
            googleMap.setOnMarkerClickListener(new GoogleMap.OnMarkerClickListener() {
                @Override
                public boolean onMarkerClick(com.google.android.gms.maps.model.Marker marker) {
                    marker.showInfoWindow();
                    return true;
                }
            });
        } else
            Toast.makeText(getApplicationContext(), "Unable to create Maps", Toast.LENGTH_SHORT).show();
    }
}

public class MarkerInfoWindowAdapter implements GoogleMap.InfoWindowAdapter {
    public MarkerInfoWindowAdapter() {
    }

    @Override
    public View getInfoWindow(Marker marker) {
        return null;
    }

    @Override
    public View getInfoContents(Marker marker) {
        View v = getLayoutInflater().inflate(R.layout.infowindow_layout, null);
        markerIcon = (ImageView) v.findViewById(R.id.marker_icon);
        Bitmap bitmap = myMarkersHash.get(marker.getId());
        markerIcon.setImageBitmap(bitmap);

        return v;
    }
}

@Override
public boolean onMarkerClick(final Marker marker) {

    return false;
}

@Override
public void onMapClick(LatLng point) {
}

@Override
public void onMapLongClick(LatLng point) {
    thePoint = point;

    drawMarker(point);
    ContentValues contentValues = new ContentValues();
    contentValues.put(LocationsDB.FIELD_LAT, point.latitude);
    contentValues.put(LocationsDB.FIELD_LNG, point.longitude);
    contentValues.put(LocationsDB.FIELD_ZOOM, googleMap.getCameraPosition().zoom);
    contentValues.put(LocationsDB.FIELD_IMAGE, imageData = baos.toByteArray());
    contentValues.put(LocationsDB.FIELD_HASH, myMarkersHash.toString());
    LocationInsertTask insertTask = new LocationInsertTask();
    insertTask.execute(contentValues);

    Intent imageIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
    File imagesFolder = new File(Environment.getExternalStorageDirectory(), "My Folder");
    imagesFolder.mkdirs();
    image = new File(imagesFolder.getPath(), "My__" + timeStamp + ".jpg");
    fileUri = Uri.fromFile(image);

    imageIntent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);
    startActivityForResult(imageIntent, TAKE_PICTURE);
}

private void drawMarker(LatLng point) {
    Marker marker = googleMap.addMarker(new MarkerOptions()
            .position(thePoint));
    markerId = marker.getId();

}

public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == TAKE_PICTURE && resultCode == RESULT_OK) {
        try {
            GetImageThumbnail getImageThumbnail = new GetImageThumbnail();
            bitmap = getImageThumbnail.getThumbnail(fileUri, this);
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        ExifInterface exif = null;

        try {
            exif = new ExifInterface(image.getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
        }
        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, -1);
        if (orientation != -1) {
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    rotate = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    rotate = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    rotate = 270;
                    break;
                default:
                    rotate = 0;
                    break;
            }
        }
        Matrix matrix = new Matrix();
        matrix.postRotate(rotate);
        bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
        baos = new ByteArrayOutputStream();
        bitmap.compress(CompressFormat.JPEG, 100, baos);
        imageData = baos.toByteArray();
        myMarkersHash.put(markerId, bitmap);
    }
}


@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
    super.onSaveInstanceState(savedInstanceState);
    savedInstanceState.putParcelable(EXTRA_PLACE, thePoint);
}

@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
    thePoint = (LatLng) savedInstanceState.getParcelable(EXTRA_PLACE);
}


@Override
public Loader<Cursor> onCreateLoader(int arg0, Bundle arg1) {
    Uri uri = LocationsContentProvider.CONTENT_URI;
    return new CursorLoader(this, uri, null, null, null, null);
}


@Override
public void onLoadFinished(Loader<Cursor> arg0, Cursor arg1) {
    int locationCount = 0;
    double lat = 0;
    double lng = 0;
    float zoom = 0;
    byte[] imagea = arg1.getBlob(1);
    ;
    float hash = 0;
    locationCount = arg1.getCount();
    arg1.moveToFirst();

    for (int i = 0; i < locationCount; i++) {

        lat = arg1.getDouble(arg1.getColumnIndex(LocationsDB.FIELD_LAT));
        lng = arg1.getDouble(arg1.getColumnIndex(LocationsDB.FIELD_LNG));
        zoom = arg1.getFloat(arg1.getColumnIndex(LocationsDB.FIELD_ZOOM));
        imagea = arg1.getBlob(arg1.getColumnIndex(LocationsDB.FIELD_IMAGE));
        hash = arg1.getFloat(arg1.getColumnIndex(LocationsDB.FIELD_HASH));
        thePoint = new LatLng(lat, lng);
        drawMarker(thePoint);
        arg1.moveToNext();
    }

    if (locationCount > 0) {
        googleMap.moveCamera(CameraUpdateFactory.newLatLng(new LatLng(lat, lng)));
        googleMap.animateCamera(CameraUpdateFactory.zoomTo(zoom));
        bitmap = BitmapFactory.decodeByteArray(imageData, 0, imageData.length);
        byte[] imagea = arg1.getBlob(1);
        markerIcon.setImageBitmap(bitmap);
        myMarkersHash.get(hash);
    }
}

@Override
public void onLoaderReset(Loader<Cursor> arg0) {

}

class LocationInsertTask extends AsyncTask<ContentValues, Void, Void> {
    @Override
    protected Void doInBackground(ContentValues... contentValues) {
        getContentResolver().insert(LocationsContentProvider.CONTENT_URI, contentValues[0]);
        return null;
    }
}

private class LocationDeleteTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... params) {
        getContentResolver().delete(LocationsContentProvider.CONTENT_URI, null, null);
        return null;
    }
}

私有谷歌地图谷歌地图；
私有静态最终字符串EXTRA_PLACE=“thePoint”；
私有静态最终int TAKE_PICTURE=0；
拉丁点；
位图；
最终上下文=此；
受保护的对话框视图；
私有Uri文件Uri；
私家车；
私有文件图像；
私人地图myMarkersHash；
私有字符串时间戳；
私有字符串markerId；
字节[]图像数据；
ByteArrayOutputStream baos；
图像视图标记；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.fragment_谷歌地图）；
myMarkersHash=新HashMap（）；
setUpMap（）；
绘图标记（mmyMarkerArray）；
}
专用空心打印标记（ArrayList标记）{
如果（markers.size（）>0）{
用于（MyMarker MyMarker:markers）{
MarkerOptions markerOption=newmarkeroptions（）.position（new LatLng（myMarker.getmLatitude（），myMarker.getmllongitude（））；
图标（BitmapDescriptorFactory.fromResource（R.drawable.ict_图标））；
Marker currentMarker=googleMap.addMarker（markerOption）；
mMarkersHashMap.put（currentMarker，myMarker）；
CameraPosition CameraPosition=新建CameraPosition.Builder（）.target(
新车床（xx.xx，xx.xx））.zoom（9）.轴承（0）.倾斜（80）.构建（）；
setOnMapLongClickListener（this）；
setOnMarkerClickListener（这个）；
setOnMapClickListener（this）；
setOnInfoWindowClickListener（这个）；
googleMap.animateCamera（CameraUpdateFactory.newCameraPosition（cameraPosition））；
googleMap.setMyLocationEnabled（true）；
googleMap.getUiSettings（）.setCompassEnabled（true）；
googleMap.getUiSettings（）.setMyLocationButtonEnabled（true）；
setInfoWindowAdapter（新的MarkerInfoWindowAdapter（））；
getSupportLoaderManager（）.initLoader（0，null，this）；
}
}
}
私有void setUpMap（）{
if（googleMap==null）{
googleMap=（（SupportMapFragment）getSupportFragmentManager（）.findFragmentById（R.id.map））.getMap（）；
if（谷歌地图！=null）{
setOnMarkerClickListener（新的googleMap.OnMarkerClickListener（）{
@凌驾
公共布尔onMarkerClick（com.google.android.gms.maps.model.Marker）{
marker.showInfoWindow（）；
返回true；
}
});
}否则
Toast.makeText（getApplicationContext（），“无法创建映射”，Toast.LENGTH_SHORT.show（）；
}
}
公共类MarkerInfoWindowAdapter实现GoogleMap.InfoWindowAdapter{
public MarkerInfoWindowAdapter（）{
}
@凌驾
公共视图getInfoWindow（标记器）{
返回null；
}
@凌驾
公共视图getInfoContents（标记器）{
视图v=GetLayoutFlater（）。充气（R.layout.infowindow\u布局，null）；
markerIcon=（ImageView）v.findViewById（R.id.marker_图标）；
位图Bitmap=myMarkersHash.get（marker.getId（））；
设置图像位图（位图）；
返回v；
}
}
@凌驾
公共布尔onMarkerClick（最终标记）{
返回false；
}
@凌驾
公共空区（停车点）{
}
@凌驾
在马普隆喀喇克（LatLng点）上的公共空隙{
点=点；
绘图标记（点）；
ContentValues ContentValues=新ContentValues（）；
contentValues.put（位置、字段纬度、点纬度）；
contentValues.put（位置、地点、经度）；
contentValues.put（LocationsDB.FIELD\u ZOOM，googleMap.getCameraPosition（）.ZOOM）；
contentValues.put（LocationsDB.FIELD_IMAGE，imageData=baos.toByteArray（））；
contentValues.put（LocationsDB.FIELD_散列，myMarkersHash.toString（））；
LocationInsertTask insertTask=新LocationInsertTask（）；
insertTask.execute（contentValues）；
Intent-imageIntent=newintent（android.provider.MediaStore.ACTION\u-IMAGE\u-CAPTURE）；
时间戳=新的SimpleDataFormat（“yyyyMMdd_HHmmss”）。格式（新日期（）；
File imagesFolder=新文件（Environment.getExternalStorageDirectory（），“我的文件夹”）；
imagesFolder.mkdirs（）；
image=new文件（imagesFolder.getPath（），“My_uu”+timeStamp+“.jpg”）；
fileUri=Uri.fromFile（图像）；
imageIntent.putExtra（MediaStore.EXTRA_输出，fileUri）；
startActivityForResult（图像意图，拍照）；
}
专用空位标记器（LatLng点）{
Marker Marker=googleMap.addMarker（新MarkerOptions（）
.位置（点）；
markerId=marker.getId（）；
}
ActivityResult上的公共void（int请求代码、int结果代码、意图数据）{
if（requestCode==拍照&&resultCode==结果(确定)）{
试一试{
GetImageThumbnail GetImageThumbnail=新建GetImageThumbnail（）；
位图=getImageThumbnail.getThumbnail（fileUri，this）；
}捕获（FileNotFoundException e1）{
e1.printStackTrace（）；
}捕获（IOE1异常）{
e1.printStackTra