src/com/android/providers/blockednumber/BlockedNumberBackupAgent.java - platform/packages/providers/BlockedNumberProvider - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * 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 com.android.providers.blockednumber;

 import android.annotation.Nullable;
 import android.app.backup.BackupAgent;
 import android.app.backup.BackupDataInput;
 import android.app.backup.BackupDataOutput;
 import android.content.ContentResolver;
 import android.content.ContentValues;
 import android.database.Cursor;
 import android.os.ParcelFileDescriptor;
 import android.provider.BlockedNumberContract;
 import android.util.Log;

 import libcore.io.IoUtils;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.SortedSet;
 import java.util.TreeSet;

 /**
  * A backup agent to enable backup and restore of blocked numbers.
  */
 public class BlockedNumberBackupAgent extends BackupAgent {
     private static final String[] BLOCKED_NUMBERS_PROJECTION = new String[] {
             BlockedNumberContract.BlockedNumbers.COLUMN_ID,
             BlockedNumberContract.BlockedNumbers.COLUMN_ORIGINAL_NUMBER,
             BlockedNumberContract.BlockedNumbers.COLUMN_E164_NUMBER,
     };
     private static final String TAG = "BlockedNumberBackup";
     private static final int VERSION = 1;
     private static final boolean DEBUG = false; // DO NOT SUBMIT WITH TRUE.

     @Override
     public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput backupDataOutput,
                          ParcelFileDescriptor newState) throws IOException {
         logV("Backing up blocked numbers.");

         DataInputStream dataInputStream =
                 new DataInputStream(new FileInputStream(oldState.getFileDescriptor()));
         final BackupState state;
         try {
             state = readState(dataInputStream);
         } finally {
             IoUtils.closeQuietly(dataInputStream);
         }

         runBackup(state, backupDataOutput, getAllBlockedNumbers());

         DataOutputStream dataOutputStream =
                 new DataOutputStream(new FileOutputStream(newState.getFileDescriptor()));
         try {
             writeNewState(dataOutputStream, state);
         } finally {
             dataOutputStream.close();
         }
     }

     @Override
     public void onRestore(BackupDataInput data, int appVersionCode,
                           ParcelFileDescriptor newState) throws IOException {
         logV("Restoring blocked numbers.");

         while (data.readNextHeader()) {
             BackedUpBlockedNumber blockedNumber = readBlockedNumberFromData(data);
             if (blockedNumber != null) {
                 writeToProvider(blockedNumber);
             }
         }
     }

     private BackupState readState(DataInputStream dataInputStream) throws IOException {
         int version = VERSION;
         if (dataInputStream.available() > 0) {
             version = dataInputStream.readInt();
         }
         BackupState state = new BackupState(version, new TreeSet<Integer>());
         while (dataInputStream.available() > 0) {
             state.ids.add(dataInputStream.readInt());
         }
         return state;
     }

     private void runBackup(BackupState state, BackupDataOutput backupDataOutput,
                            Iterable<BackedUpBlockedNumber> allBlockedNumbers) throws IOException {
         SortedSet<Integer> deletedBlockedNumbers = new TreeSet<>(state.ids);

         for (BackedUpBlockedNumber blockedNumber : allBlockedNumbers) {
             if (state.ids.contains(blockedNumber.id)) {
                 // Existing blocked number: do not delete.
                 deletedBlockedNumbers.remove(blockedNumber.id);
             } else {
                 logV("Adding blocked number to backup: " + blockedNumber);
                 // New blocked number
                 addToBackup(backupDataOutput, blockedNumber);
                 state.ids.add(blockedNumber.id);
             }
         }

         for (int id : deletedBlockedNumbers) {
             logV("Removing blocked number from backup: " + id);
             removeFromBackup(backupDataOutput, id);
             state.ids.remove(id);
         }
     }

     private void addToBackup(BackupDataOutput output, BackedUpBlockedNumber blockedNumber)
             throws IOException {
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
         DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
         dataOutputStream.writeInt(VERSION);
         writeString(dataOutputStream, blockedNumber.originalNumber);
         writeString(dataOutputStream, blockedNumber.e164Number);
         dataOutputStream.flush();

         output.writeEntityHeader(Integer.toString(blockedNumber.id), outputStream.size());
         output.writeEntityData(outputStream.toByteArray(), outputStream.size());
     }

     private void writeString(DataOutputStream dataOutputStream, @Nullable String value)
             throws IOException {
         if (value == null) {
             dataOutputStream.writeBoolean(false);
         } else {
             dataOutputStream.writeBoolean(true);
             dataOutputStream.writeUTF(value);
         }
     }

     @Nullable
     private String readString(DataInputStream dataInputStream)
             throws IOException {
         if (dataInputStream.readBoolean()) {
             return dataInputStream.readUTF();
         } else {
             return null;
         }
     }

     private void removeFromBackup(BackupDataOutput output, int id) throws IOException {
         output.writeEntityHeader(Integer.toString(id), -1);
     }

     private Iterable<BackedUpBlockedNumber> getAllBlockedNumbers() {
         List<BackedUpBlockedNumber> blockedNumbers = new ArrayList<>();
         ContentResolver resolver = getContentResolver();
         Cursor cursor = resolver.query(
                 BlockedNumberContract.BlockedNumbers.CONTENT_URI, BLOCKED_NUMBERS_PROJECTION, null,
                 null, null);
         if (cursor != null) {
             try {
                 while (cursor.moveToNext()) {
                     blockedNumbers.add(createBlockedNumberFromCursor(cursor));
                 }
             } finally {
                 cursor.close();
             }
         }
         return blockedNumbers;
     }

     private BackedUpBlockedNumber createBlockedNumberFromCursor(Cursor cursor) {
         return new BackedUpBlockedNumber(
                 cursor.getInt(0), cursor.getString(1), cursor.getString(2));
     }

     private void writeNewState(DataOutputStream dataOutputStream, BackupState state)
             throws IOException {
         dataOutputStream.writeInt(VERSION);
         for (int i : state.ids) {
             dataOutputStream.writeInt(i);
         }
     }

     @Nullable
     private BackedUpBlockedNumber readBlockedNumberFromData(BackupDataInput data) {
         int id;
         try {
             id = Integer.parseInt(data.getKey());
         } catch (NumberFormatException e) {
             Log.e(TAG, "Unexpected key found in restore: " + data.getKey());
             return null;
         }

         try {
             byte[] byteArray = new byte[data.getDataSize()];
             data.readEntityData(byteArray, 0, byteArray.length);
             DataInputStream dataInput = new DataInputStream(new ByteArrayInputStream(byteArray));
             dataInput.readInt(); // Ignore version.
             BackedUpBlockedNumber blockedNumber =
                     new BackedUpBlockedNumber(id, readString(dataInput), readString(dataInput));
             logV("Restoring blocked number: " + blockedNumber);
             return blockedNumber;
         } catch (IOException e) {
             Log.e(TAG, "Error reading blocked number for: " + id + ": " + e.getMessage());
             return null;
         }
     }

     private void writeToProvider(BackedUpBlockedNumber blockedNumber) {
         ContentValues contentValues = new ContentValues();
         contentValues.put(BlockedNumberContract.BlockedNumbers.COLUMN_ORIGINAL_NUMBER,
                 blockedNumber.originalNumber);
         contentValues.put(BlockedNumberContract.BlockedNumbers.COLUMN_E164_NUMBER,
                 blockedNumber.e164Number);
         try {
             getContentResolver().insert(
                     BlockedNumberContract.BlockedNumbers.CONTENT_URI, contentValues);
         } catch (Exception e) {
             Log.e(TAG, "Unable to insert blocked number " + blockedNumber + " :" + e.getMessage());
         }
     }

     private static boolean isDebug() {
         return Log.isLoggable(TAG, Log.DEBUG);
     }

     private static void logV(String msg) {
         if (DEBUG) {
             Log.v(TAG, msg);
         }
     }

     private static class BackupState {
         final int version;
         final SortedSet<Integer> ids;

         BackupState(int version, SortedSet<Integer> ids) {
             this.version = version;
             this.ids = ids;
         }
     }

     private static class BackedUpBlockedNumber {
         final int id;
         final String originalNumber;
         final String e164Number;

         BackedUpBlockedNumber(int id, String originalNumber, String e164Number) {
             this.id = id;
             this.originalNumber = originalNumber;
             this.e164Number = e164Number;
         }

         @Override
         public String toString() {
             if (isDebug()) {
                 return String.format("[%d, original number: %s, e164 number: %s]",
                         id, originalNumber, e164Number);
             } else {
                 return String.format("[%d]", id);
             }
         }
     }
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* 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 com.android.providers.blockednumber;

	import android.annotation.Nullable;
	import android.app.backup.BackupAgent;
	import android.app.backup.BackupDataInput;
	import android.app.backup.BackupDataOutput;
	import android.content.ContentResolver;
	import android.content.ContentValues;
	import android.database.Cursor;
	import android.os.ParcelFileDescriptor;
	import android.provider.BlockedNumberContract;
	import android.util.Log;

	import libcore.io.IoUtils;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.DataInputStream;
	import java.io.DataOutputStream;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.SortedSet;
	import java.util.TreeSet;

	/**
	* A backup agent to enable backup and restore of blocked numbers.
	*/
	public class BlockedNumberBackupAgent extends BackupAgent {
	private static final String[] BLOCKED_NUMBERS_PROJECTION = new String[] {
	BlockedNumberContract.BlockedNumbers.COLUMN_ID,
	BlockedNumberContract.BlockedNumbers.COLUMN_ORIGINAL_NUMBER,
	BlockedNumberContract.BlockedNumbers.COLUMN_E164_NUMBER,
	};
	private static final String TAG = "BlockedNumberBackup";
	private static final int VERSION = 1;
	private static final boolean DEBUG = false; // DO NOT SUBMIT WITH TRUE.

	@Override
	public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput backupDataOutput,
	ParcelFileDescriptor newState) throws IOException {
	logV("Backing up blocked numbers.");

	DataInputStream dataInputStream =
	new DataInputStream(new FileInputStream(oldState.getFileDescriptor()));
	final BackupState state;
	try {
	state = readState(dataInputStream);
	} finally {
	IoUtils.closeQuietly(dataInputStream);
	}

	runBackup(state, backupDataOutput, getAllBlockedNumbers());

	DataOutputStream dataOutputStream =
	new DataOutputStream(new FileOutputStream(newState.getFileDescriptor()));
	try {
	writeNewState(dataOutputStream, state);
	} finally {
	dataOutputStream.close();
	}
	}

	@Override
	public void onRestore(BackupDataInput data, int appVersionCode,
	ParcelFileDescriptor newState) throws IOException {
	logV("Restoring blocked numbers.");

	while (data.readNextHeader()) {
	BackedUpBlockedNumber blockedNumber = readBlockedNumberFromData(data);
	if (blockedNumber != null) {
	writeToProvider(blockedNumber);
	}
	}
	}

	private BackupState readState(DataInputStream dataInputStream) throws IOException {
	int version = VERSION;
	if (dataInputStream.available() > 0) {
	version = dataInputStream.readInt();
	}
	BackupState state = new BackupState(version, new TreeSet<Integer>());
	while (dataInputStream.available() > 0) {
	state.ids.add(dataInputStream.readInt());
	}
	return state;
	}

	private void runBackup(BackupState state, BackupDataOutput backupDataOutput,
	Iterable<BackedUpBlockedNumber> allBlockedNumbers) throws IOException {
	SortedSet<Integer> deletedBlockedNumbers = new TreeSet<>(state.ids);

	for (BackedUpBlockedNumber blockedNumber : allBlockedNumbers) {
	if (state.ids.contains(blockedNumber.id)) {
	// Existing blocked number: do not delete.
	deletedBlockedNumbers.remove(blockedNumber.id);
	} else {
	logV("Adding blocked number to backup: " + blockedNumber);
	// New blocked number
	addToBackup(backupDataOutput, blockedNumber);
	state.ids.add(blockedNumber.id);
	}
	}

	for (int id : deletedBlockedNumbers) {
	logV("Removing blocked number from backup: " + id);
	removeFromBackup(backupDataOutput, id);
	state.ids.remove(id);
	}
	}

	private void addToBackup(BackupDataOutput output, BackedUpBlockedNumber blockedNumber)
	throws IOException {
	ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
	DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
	dataOutputStream.writeInt(VERSION);
	writeString(dataOutputStream, blockedNumber.originalNumber);
	writeString(dataOutputStream, blockedNumber.e164Number);
	dataOutputStream.flush();

	output.writeEntityHeader(Integer.toString(blockedNumber.id), outputStream.size());
	output.writeEntityData(outputStream.toByteArray(), outputStream.size());
	}

	private void writeString(DataOutputStream dataOutputStream, @Nullable String value)
	throws IOException {
	if (value == null) {
	dataOutputStream.writeBoolean(false);
	} else {
	dataOutputStream.writeBoolean(true);
	dataOutputStream.writeUTF(value);
	}
	}

	@Nullable
	private String readString(DataInputStream dataInputStream)
	throws IOException {
	if (dataInputStream.readBoolean()) {
	return dataInputStream.readUTF();
	} else {
	return null;
	}
	}

	private void removeFromBackup(BackupDataOutput output, int id) throws IOException {
	output.writeEntityHeader(Integer.toString(id), -1);
	}

	private Iterable<BackedUpBlockedNumber> getAllBlockedNumbers() {
	List<BackedUpBlockedNumber> blockedNumbers = new ArrayList<>();
	ContentResolver resolver = getContentResolver();
	Cursor cursor = resolver.query(
	BlockedNumberContract.BlockedNumbers.CONTENT_URI, BLOCKED_NUMBERS_PROJECTION, null,
	null, null);
	if (cursor != null) {
	try {
	while (cursor.moveToNext()) {
	blockedNumbers.add(createBlockedNumberFromCursor(cursor));
	}
	} finally {
	cursor.close();
	}
	}
	return blockedNumbers;
	}

	private BackedUpBlockedNumber createBlockedNumberFromCursor(Cursor cursor) {
	return new BackedUpBlockedNumber(
	cursor.getInt(0), cursor.getString(1), cursor.getString(2));
	}

	private void writeNewState(DataOutputStream dataOutputStream, BackupState state)
	throws IOException {
	dataOutputStream.writeInt(VERSION);
	for (int i : state.ids) {
	dataOutputStream.writeInt(i);
	}
	}

	@Nullable
	private BackedUpBlockedNumber readBlockedNumberFromData(BackupDataInput data) {
	int id;
	try {
	id = Integer.parseInt(data.getKey());
	} catch (NumberFormatException e) {
	Log.e(TAG, "Unexpected key found in restore: " + data.getKey());
	return null;
	}

	try {
	byte[] byteArray = new byte[data.getDataSize()];
	data.readEntityData(byteArray, 0, byteArray.length);
	DataInputStream dataInput = new DataInputStream(new ByteArrayInputStream(byteArray));
	dataInput.readInt(); // Ignore version.
	BackedUpBlockedNumber blockedNumber =
	new BackedUpBlockedNumber(id, readString(dataInput), readString(dataInput));
	logV("Restoring blocked number: " + blockedNumber);
	return blockedNumber;
	} catch (IOException e) {
	Log.e(TAG, "Error reading blocked number for: " + id + ": " + e.getMessage());
	return null;
	}
	}

	private void writeToProvider(BackedUpBlockedNumber blockedNumber) {
	ContentValues contentValues = new ContentValues();
	contentValues.put(BlockedNumberContract.BlockedNumbers.COLUMN_ORIGINAL_NUMBER,
	blockedNumber.originalNumber);
	contentValues.put(BlockedNumberContract.BlockedNumbers.COLUMN_E164_NUMBER,
	blockedNumber.e164Number);
	try {
	getContentResolver().insert(
	BlockedNumberContract.BlockedNumbers.CONTENT_URI, contentValues);
	} catch (Exception e) {
	Log.e(TAG, "Unable to insert blocked number " + blockedNumber + " :" + e.getMessage());
	}
	}

	private static boolean isDebug() {
	return Log.isLoggable(TAG, Log.DEBUG);
	}

	private static void logV(String msg) {
	if (DEBUG) {
	Log.v(TAG, msg);
	}
	}

	private static class BackupState {
	final int version;
	final SortedSet<Integer> ids;

	BackupState(int version, SortedSet<Integer> ids) {
	this.version = version;
	this.ids = ids;
	}
	}

	private static class BackedUpBlockedNumber {
	final int id;
	final String originalNumber;
	final String e164Number;

	BackedUpBlockedNumber(int id, String originalNumber, String e164Number) {
	this.id = id;
	this.originalNumber = originalNumber;
	this.e164Number = e164Number;
	}

	@Override
	public String toString() {
	if (isDebug()) {
	return String.format("[%d, original number: %s, e164 number: %s]",
	id, originalNumber, e164Number);
	} else {
	return String.format("[%d]", id);
	}
	}
	}
	}