Beispiel #1
0
/*  SRSendNewDatabase - send a change-database request to server
 *
 *  psz     name of new database.  This name is rootpath'd as the
 *          server may be operating on a different directory/drive
 */
void SRSendNewDatabase (PSZ psz)
{
    char szFile[MAX_PATH];

    {
	char szTmp[MAX_PATH];

	rootpath (psz, szTmp);

	GetGlobalName (szTmp, szFile);
    }

    {
	HANDLE hServer;
	char sz[CBMSG];

	sprintf (sz, "%s %s", CMD_SET_DATABASE, szFile);

	hServer = OpenDatabase (FALSE);

	SendSz (hServer, sz);

	CloseDatabase (hServer);
    }
}
Beispiel #2
0
/*  SRSendAddDirectory - send an index-file request to server
 *
 *  psz     name of file to be indexed. This name is rootpath'd as the
 *          server may be operating on a different directory/drive
 */
void SRSendAddDirectory (PSZ psz)
{
    char szFile[MAX_PATH];

    {
	char szTmp[MAX_PATH];

	rootpath (psz, szTmp);

	GetGlobalName (szTmp, szFile);
    }

    {
	HANDLE hServer;
	char sz[CBMSG];

	sprintf (sz, "%s %s", CMD_ADD_DIRECTORY, szFile);

	printf ("%s", szFile);

	hServer = OpenDatabase (TRUE);

	SendSz (hServer, sz);

	CloseDatabase (hServer);

	printf ("\n");
    }

}
/*
 * Write files to the given output.  This implementation does *not* create
 * a standalone archive suitable for restore on its own.  In particular, the identification of
 * the application's name etc is not in-band here; it's assumed that the calling code has
 * taken care of supplying that information previously in the output stream.
 *
 * The file format is 'tar's, with special semantics applied by use of a "fake" directory
 * hierarchy within the tar stream:
 *
 * apps/packagename/a/Filename.apk - this is an actual application binary, which will be
 *   installed on the target device at restore time.  These need to appear first in the tar
 *   stream.
 * apps/packagename/obb/[relpath] - OBB containers belonging the app
 * apps/packagename/r/[relpath] - these are files at the root of the app's data tree
 * apps/packagename/f/[relpath] - this is a file within the app's getFilesDir() tree, stored
 *   at [relpath] relative to the top of that tree.
 * apps/packagename/db/[relpath] - as with "files" but for the getDatabasePath() tree
 * apps/packagename/sp/[relpath] - as with "files" but for the getSharedPrefsFile() tree
 * apps/packagename/c/[relpath] - as with "files" but for the getCacheDir() tree
 *
 * and for the shared storage hierarchy:
 *
 * shared/[relpaths] - files belonging in the device's shared storage location.  This will
 *    *not* include .obb files; those are saved with their owning apps.
 *
 * This method writes one file data block.  'domain' is the name of the appropriate pseudo-
 * directory to be applied for this file; 'linkdomain' is the pseudo-dir for a relative
 * symlink's antecedent.
 *
 * packagename: the package name to use as the top level directory tag
 * domain:      which semantic name the file is to be stored under (a, r, f, db, etc)
 * linkdomain:  where a symlink points for purposes of rewriting; current unused
 * rootpath:    prefix to be snipped from full path when encoding in tar
 * path:        absolute path to the file to be saved
 * dataOutput:  the BackupDataOutput object that we're saving into
 */
static int backupToTar(JNIEnv* env, jobject clazz, jstring packageNameObj,
        jstring domainObj, jstring linkdomain,
        jstring rootpathObj, jstring pathObj, jobject dataOutputObj) {
    int ret;

    // Extract the various strings, allowing for null object pointers
    const char* packagenamechars = (packageNameObj) ? env->GetStringUTFChars(packageNameObj, NULL) : NULL;
    const char* rootchars = (rootpathObj) ? env->GetStringUTFChars(rootpathObj, NULL) : NULL;
    const char* pathchars = (pathObj) ? env->GetStringUTFChars(pathObj, NULL) : NULL;
    const char* domainchars = (domainObj) ? env->GetStringUTFChars(domainObj, NULL) : NULL;

    String8 packageName(packagenamechars ? packagenamechars : "");
    String8 rootpath(rootchars ? rootchars : "");
    String8 path(pathchars ? pathchars : "");
    String8 domain(domainchars ? domainchars : "");

    if (domainchars) env->ReleaseStringUTFChars(domainObj, domainchars);
    if (pathchars) env->ReleaseStringUTFChars(pathObj, pathchars);
    if (rootchars) env->ReleaseStringUTFChars(rootpathObj, rootchars);
    if (packagenamechars) env->ReleaseStringUTFChars(packageNameObj, packagenamechars);

    // Extract the data output fd
    BackupDataWriter* writer = (BackupDataWriter*) env->GetIntField(dataOutputObj,
            sBackupDataOutput.mBackupWriter);

    // Validate
    if (!writer) {
        LOGE("No output stream provided [%s]", path.string());
        return -1;
    }

    if (path.length() < rootpath.length()) {
        LOGE("file path [%s] shorter than root path [%s]",
                path.string(), rootpath.string());
        return -1;
    }

    return write_tarfile(packageName, domain, rootpath, path, writer);
}
void Exporter::extractJointData(MDagPath path)
{
	MFnTransform joint(path);
	int childcount = joint.childCount();
	MFnDagNode rootpath(joint.parent(0));

	if (!strcmp(rootpath.fullPathName().asChar(), ""))
		RecursiveJointExtraction(joint, -1);




	// 	MFloatMatrix res;
	// 	cout << path.partialPathName().asChar() << std::endl;
	// 	MMatrix invMat;
	// 
	// 	MStatus status;
	// 	MTransformationMatrix restpose = joint.restPosition(&status);
	// 
	// 	cout << status <<" "<< restpose.asMatrix() << endl;
	// 
	// 
	// 	jointTrans jt;
	// 
	// 	//attach the function set to the object
	// 	MFnTransform tr(path);
	// 
	// 	// Gets transform data as a matrix, though quaternions more interesting! :D
	// 	MMatrix mat = tr.transformation().asMatrix();
	// 
	// 	MQuaternion JointOrient(0, 0, 0, 1);
	// 	MQuaternion Rotation(0, 0, 0, 1);
	// 
	// 	//Get the transforms local translation
	// 	MVector Translation = tr.translation(MSpace::kTransform);
	// 
	// 	//Get the transforms scale
	// 	tr.getScale(jt.scale);
	// 
	// 	//Get the transforms rotation as quaternions
	// 	tr.getRotation(Rotation);
	// 
	// 	//IK joints contains both joint orientations as well as a rotation, therefore I check for the transform of an IK
	// 	if (tr.object().hasFn(MFn::kJoint))
	// 	{
	// 		MFnIkJoint IKjoint(tr.object());
	// 		IKjoint.getOrientation(JointOrient);
	// 	}
	// 
	// 	//Get Translation data
	// 	jt.tx = Translation.x;
	// 	jt.ty = Translation.y;
	// 	jt.tz = Translation.z;
	// 
	// 	//Get Rotation Data
	// 	jt.rx = Rotation.x;
	// 	jt.ry = Rotation.y;
	// 	jt.rz = Rotation.z;
	// 	jt.rw = Rotation.w;
	// 
	// 	//Get Joint Orientation Data
	// 	jt.rox = JointOrient.x;
	// 	jt.roy = JointOrient.y;
	// 	jt.roz = JointOrient.z;
	// 	jt.row = JointOrient.w;
	// 
	// 
	// 	MObject jointNode = path.node();
	// 	MFnDependencyNode fnJoint(jointNode);
	// 	MObject attrWorldMatrix = fnJoint.attribute("worldMatrix");
	// 
	// 	MPlug plugWorldMatrixArray(jointNode, attrWorldMatrix);
	// 
	// 	for (unsigned i = 0; i < plugWorldMatrixArray.numElements(); i++)
	// 	{
	// 		MPlug elementPlug = plugWorldMatrixArray[i];
	// 
	// 		MItDependencyGraph dgIt(elementPlug, MFn::kInvalid, MItDependencyGraph::kDownstream, MItDependencyGraph::kDepthFirst, MItDependencyGraph::kPlugLevel);
	// 
	// 		dgIt.disablePruningOnFilter();
	// 
	// 		for (; !dgIt.isDone(); dgIt.next())
	// 		{
	// 			MObject thisNode = dgIt.thisNode();
	// 
	// 			if (thisNode.apiType() == MFn::kSkinClusterFilter)
	// 			{
	// 				MFnSkinCluster skinFn(thisNode);
	// 
	// 				MPlug bindPreMatrixArrayPlug = skinFn.findPlug("bindPreMatrix");
	// 				int logicalIndex = skinFn.indexForInfluenceObject(path);
	// 				MPlug bindPreMatrixPlug = bindPreMatrixArrayPlug.elementByLogicalIndex(logicalIndex);
	// 				MObject dataObject;
	// 				bindPreMatrixArrayPlug.getValue(dataObject);
	// 
	// 				MFnMatrixData matDataFn(dataObject);
	// 
	// 				invMat = matDataFn.matrix().inverse();
	// 				res = invMat.matrix;
	// 				cout << logicalIndex << std::endl;
	// 			}
	// 		}
	// 	}
	// 	std::cout << res << std::endl;
}